Leahnaya/pokeplatinum
1
0
Fork 0
mirror of https://github.com/pret/pokeplatinum.git synced 2026-04-24 23:18:36 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

document BufferManager/ScreenScrollManager

Browse Source
This commit is contained in:
Fexty12573 2024-06-13 14:51:51 +02:00
parent 8d4c2142f1
commit 91ba1a2da7
14 changed files with 284 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/overlay100/struct_ov100_021D4E3C.h
View File

@ -5,7 +5,7 @@
#include "struct_decls/sys_task.h"
typedef struct {
UnkStruct_02013BE0 * unk_00;
ScreenScrollManager * unk_00;
SysTask * unk_04;
u32 unk_08;
} UnkStruct_ov100_021D4E3C;

2
include/overlay104/struct_ov104_0223F094.h
View File

@ -5,7 +5,7 @@
#include "struct_decls/sys_task.h"
typedef struct {
UnkStruct_02013BE0 * unk_00;
ScreenScrollManager * unk_00;
SysTask * unk_04;
u32 unk_08;
} UnkStruct_ov104_0223F094;

2
include/struct_decls/struct_02013B10_decl.h
View File

@ -1,6 +1,6 @@
#ifndef POKEPLATINUM_STRUCT_02013B10_DECL_H
#define POKEPLATINUM_STRUCT_02013B10_DECL_H
typedef struct UnkStruct_02013B10_t UnkStruct_02013B10;
typedef struct BufferManager BufferManager;
#endif // POKEPLATINUM_STRUCT_02013B10_DECL_H

2
include/struct_decls/struct_02013BE0_decl.h
View File

@ -1,6 +1,6 @@
#ifndef POKEPLATINUM_STRUCT_02013BE0_DECL_H
#define POKEPLATINUM_STRUCT_02013BE0_DECL_H
typedef struct UnkStruct_02013BE0_t UnkStruct_02013BE0;
typedef struct ScreenScrollManager ScreenScrollManager;
#endif // POKEPLATINUM_STRUCT_02013BE0_DECL_H

47
include/unk_02013B10.h
View File

@ -3,23 +3,36 @@
#include "struct_decls/struct_02013B10_decl.h"
#include "struct_decls/struct_02013BE0_decl.h"
#include "constants/heap.h"
UnkStruct_02013B10 * sub_02013B10(int param0, void * param1, void * param2);
void sub_02013B40(UnkStruct_02013B10 * param0);
void * sub_02013B54(const UnkStruct_02013B10 * param0);
const void * sub_02013B68(const UnkStruct_02013B10 * param0);
void sub_02013B80(UnkStruct_02013B10 * param0, u8 param1);
void sub_02013B94(UnkStruct_02013B10 * param0);
void sub_02013BA8(void);
void sub_02013BB8(const void * param0, void * param1, int param2, int param3);
UnkStruct_02013BE0 * sub_02013BE0(int param0);
void sub_02013C10(UnkStruct_02013BE0 * param0, u8 param1, u8 param2, u16 param3, fx32 param4, s16 param5, u32 param6, u32 param7, u32 param8);
void sub_02013CA4(UnkStruct_02013BE0 * param0, u8 param1, u8 param2, u16 param3, fx32 param4, s16 param5, u32 param6, u32 param7, u32 param8);
void sub_02013D38(UnkStruct_02013BE0 * param0);
void sub_02013D74(UnkStruct_02013BE0 * param0);
void * sub_02013D94(UnkStruct_02013BE0 * param0);
void sub_02013DA4(UnkStruct_02013BE0 * param0);
void sub_02013DDC(UnkStruct_02013BE0 * param0);
void sub_02013DFC(s16 * param0, u32 param1, u16 param2, fx32 param3);
#define BUFFER_MANAGER_MODE_SINGLE 0
#define BUFFER_MANAGER_MODE_DOUBLE 1
#define SCREEN_SCROLL_MANAGER_BUFFER_SIZE 192
#define SCREEN_SCROLL_MANAGER_SCALING_FACTOR 100
#define SCREEN_SCROLL_MANAGER_MAX_SCROLL (SCREEN_SCROLL_MANAGER_BUFFER_SIZE * SCREEN_SCROLL_MANAGER_SCALING_FACTOR)
enum BufferManagerDMAType {
BUFFER_MANAGER_DMA_TYPE_16BIT = 0,
BUFFER_MANAGER_DMA_TYPE_32BIT = 1
};
BufferManager *BufferManager_New(enum HeapId heapID, void *buffer1, void *buffer2);
void BufferManager_Delete(BufferManager *bufferManager);
void *BufferManager_GetWriteBuffer(const BufferManager *bufferManager);
const void *BufferManager_GetReadBuffer(const BufferManager *bufferManager);
void BufferManager_SetMode(BufferManager *bufferManager, u8 mode);
void BufferManager_SwapBuffers(BufferManager *bufferManager);
void BufferManager_StopDMA(void);
void BufferManager_StartDMA(const void *src, void *dst, int size, enum BufferManagerDMAType dmaType);
ScreenScrollManager *ScreenScrollManager_New(enum HeapId heapID);
void ScreenScrollManager_ScrollX(ScreenScrollManager *screenScrollMgr, u8 start, u8 end, u16 angleIncrement, fx32 amplitude, s16 speed, u32 bg, u32 initValue, u32 priority);
void ScreenScrollManager_ScrollY(ScreenScrollManager *screenScrollMgr, u8 start, u8 end, u16 angleIncrement, fx32 amplitude, s16 speed, u32 bg, u32 initValue, u32 priority);
void ScreenScrollManager_Stop(ScreenScrollManager *screenScrollMgr);
void ScreenScrollManager_Delete(ScreenScrollManager *screenScrollMgr);
void *ScreenScrollManager_GetWriteBuffer(ScreenScrollManager *screenScrollMgr);
void ScreenScrollManager_SwapBuffers(ScreenScrollManager *screenScrollMgr);
void ScreenScrollManager_RestartDMA(ScreenScrollManager *screenScrollMgr);
void ScreenScrollManager_CreateSineTable(s16 *dest, u32 entryCount, u16 angleIncrement, fx32 amplitude);
#endif // POKEPLATINUM_UNK_02013B10_H

16
src/overlay005/encounter_effect_core.c
View File

@ -92,7 +92,7 @@ typedef struct TallGrassEncounterEffect {
} TallGrassEncounterEffect;
typedef struct {
UnkStruct_02013BE0 * unk_00;
ScreenScrollManager * unk_00;
SysTask * dmaTransferTask;
u32 unk_08;
} ScreenShakeEffect;
@ -434,17 +434,17 @@ static void ScreenShakeEffect_DMATransfer(SysTask *task, void *param)
ScreenShakeEffect *screenShakeEfx = param;
if (screenShakeEfx->unk_08 >= 2) {
sub_02013DA4(screenShakeEfx->unk_00);
ScreenScrollManager_SwapBuffers(screenShakeEfx->unk_00);
screenShakeEfx->unk_08 = 0;
}
sub_02013DDC(screenShakeEfx->unk_00);
ScreenScrollManager_RestartDMA(screenShakeEfx->unk_00);
screenShakeEfx->unk_08++;
}
static void ScreenShakeEffect_Init(ScreenShakeEffect *screenShake, u32 heapID)
{
screenShake->unk_00 = sub_02013BE0(heapID);
screenShake->unk_00 = ScreenScrollManager_New(heapID);
screenShake->unk_08 = 0;
screenShake->dmaTransferTask = ScreenShakeEffect_CreateDMATransferTask(screenShake);
}
@ -452,13 +452,13 @@ static void ScreenShakeEffect_Init(ScreenShakeEffect *screenShake, u32 heapID)
static void ScreenShakeEffect_Finish (ScreenShakeEffect *screenShake)
{
SysTask_Done(screenShake->dmaTransferTask);
sub_02013D38(screenShake->unk_00);
sub_02013D74(screenShake->unk_00);
ScreenScrollManager_Stop(screenShake->unk_00);
ScreenScrollManager_Delete(screenShake->unk_00);
}
static void ScreenShakeEffect_Start(ScreenShakeEffect *screenShake, u8 startX, u8 endX, u16 angleIncrement, fx32 sineRadius, s16 shakeSpeed, u32 bg, u32 defaultValue, u32 priority)
{
sub_02013C10(screenShake->unk_00, startX, endX, angleIncrement, sineRadius, shakeSpeed, bg, defaultValue, priority);
ScreenScrollManager_ScrollX(screenShake->unk_00, startX, endX, angleIncrement, sineRadius, shakeSpeed, bg, defaultValue, priority);
}
static void ov5_021E290C(ScreenShakeEffect *screenShake, u32 param1)
@ -467,7 +467,7 @@ static void ov5_021E290C(ScreenShakeEffect *screenShake, u32 param1)
int v1;
s16 v2;
v0 = sub_02013D94(screenShake->unk_00);
v0 = ScreenScrollManager_GetWriteBuffer(screenShake->unk_00);
for (v1 = 0; v1 < 192; v1++) {
v2 = v0[v1] & 0xffff;

22
src/overlay005/ov5_021D5EB8.c
View File

@ -228,7 +228,7 @@ typedef struct {
UnkStruct_ov5_021D6538 unk_04;
HBlankSystem * unk_14;
HBlankTask * unk_18;
UnkStruct_02013B10 * unk_1C[2];
BufferManager * unk_1C[2];
SysTask * unk_24;
u32 unk_28;
u16 unk_2C[4][192];
@ -5354,8 +5354,8 @@ static void ov5_021DB500 (UnkStruct_ov5_021DB614 * param0)
u16 * v3;
u16 * v4;
v3 = sub_02013B54(param0->unk_1C[0]);
v4 = sub_02013B54(param0->unk_1C[1]);
v3 = BufferManager_GetWriteBuffer(param0->unk_1C[0]);
v4 = BufferManager_GetWriteBuffer(param0->unk_1C[1]);
for (v0 = 0; v0 < 192; v0++) {
if (v0 <= param0->unk_02) {
@ -5415,8 +5415,8 @@ static void ov5_021DB614 (UnkStruct_ov5_021DB614 * param0, HBlankSystem * param1
memset(param0, 0, sizeof(UnkStruct_ov5_021DB614));
param0->unk_1C[0] = sub_02013B10(4, param0->unk_2C[0], param0->unk_2C[1]);
param0->unk_1C[1] = sub_02013B10(4, param0->unk_2C[2], param0->unk_2C[3]);
param0->unk_1C[0] = BufferManager_New(4, param0->unk_2C[0], param0->unk_2C[1]);
param0->unk_1C[1] = BufferManager_New(4, param0->unk_2C[2], param0->unk_2C[3]);
for (v0 = 0; v0 < 192; v0++) {
param0->unk_2C[2][v0] = 255;
@ -5437,8 +5437,8 @@ static void ov5_021DB690 (UnkStruct_ov5_021DB614 * param0)
HBlankTask_Delete(param0->unk_18);
SysTask_Done(param0->unk_24);
sub_02013B40(param0->unk_1C[0]);
sub_02013B40(param0->unk_1C[1]);
BufferManager_Delete(param0->unk_1C[0]);
BufferManager_Delete(param0->unk_1C[1]);
memset(param0, 0, sizeof(UnkStruct_ov5_021DB614));
}
@ -5484,7 +5484,7 @@ static void ov5_021DB72C (HBlankTask * param0, void * param1)
v2 = GX_GetVCount();
for (v3 = 0; v3 < 2; v3++) {
v1[v3] = sub_02013B68(v0->unk_1C[v3]);
v1[v3] = BufferManager_GetReadBuffer(v0->unk_1C[v3]);
}
if (v2 < 192) {
@ -5506,7 +5506,7 @@ static void ov5_021DB78C (SysTask * param0, void * param1)
int v1;
for (v1 = 0; v1 < 2; v1++) {
sub_02013B94(v0->unk_1C[v1]);
BufferManager_SwapBuffers(v0->unk_1C[v1]);
}
}
@ -5528,8 +5528,8 @@ static void ov5_021DB7CC (UnkStruct_ov5_021DB614 * param0)
int v2;
for (v2 = 0; v2 < 2; v2++) {
v0 = sub_02013B68(param0->unk_1C[v2]);
v1 = sub_02013B54(param0->unk_1C[v2]);
v0 = BufferManager_GetReadBuffer(param0->unk_1C[v2]);
v1 = BufferManager_GetWriteBuffer(param0->unk_1C[v2]);
memcpy(v1, v0, sizeof(u16) * 192);
}

14
src/overlay005/ov5_021EF4BC.c
View File

@ -17,7 +17,7 @@ typedef struct UnkStruct_ov5_021EF4F8_t {
int unk_08;
u16 unk_0C[192];
u16 unk_18C[192];
UnkStruct_02013B10 * unk_30C;
BufferManager * unk_30C;
HBlankSystem * unk_310;
HBlankTask * unk_314;
BOOL unk_318;
@ -44,7 +44,7 @@ UnkStruct_ov5_021EF4F8 * ov5_021EF4BC (u32 param0, HBlankSystem * param1)
memset(v0, 0, sizeof(UnkStruct_ov5_021EF4F8));
v0->unk_00 = 0;
v0->unk_30C = sub_02013B10(param0, v0->unk_0C, v0->unk_18C);
v0->unk_30C = BufferManager_New(param0, v0->unk_0C, v0->unk_18C);
v0->unk_310 = param1;
return v0;
@ -56,7 +56,7 @@ void ov5_021EF4F8 (UnkStruct_ov5_021EF4F8 * param0)
ov5_021EF710(param0);
}
sub_02013B40(param0->unk_30C);
BufferManager_Delete(param0->unk_30C);
Heap_FreeToHeap(param0);
}
@ -90,7 +90,7 @@ static void ov5_021EF5A8 (SysTask * param0, void * param1)
break;
case 1:
v0->unk_04--;
v1 = sub_02013B54(v0->unk_30C);
v1 = BufferManager_GetWriteBuffer(v0->unk_30C);
ov5_021EF66C(v1, 3 - v0->unk_04, 3);
@ -101,7 +101,7 @@ static void ov5_021EF5A8 (SysTask * param0, void * param1)
break;
case 2:
v0->unk_04--;
v1 = sub_02013B54(v0->unk_30C);
v1 = BufferManager_GetWriteBuffer(v0->unk_30C);
ov5_021EF66C(v1, v0->unk_04, 3);
@ -122,7 +122,7 @@ static void ov5_021EF634 (UnkStruct_ov5_021EF4F8 * param0)
int v1;
v1 = GX_GetVCount();
v0 = sub_02013B68(param0->unk_30C);
v0 = BufferManager_GetReadBuffer(param0->unk_30C);
if (v1 < 192) {
v1++;
@ -191,7 +191,7 @@ static void ov5_021EF6E4 (SysTask * param0, void * param1)
static void ov5_021EF6F0 (UnkStruct_ov5_021EF4F8 * param0)
{
if (param0->unk_00 == 1) {
sub_02013B94(param0->unk_30C);
BufferManager_SwapBuffers(param0->unk_30C);
param0->unk_318 = 1;
}
}

36
src/overlay012/ov12_02225864.c
View File

@ -48,7 +48,7 @@ typedef struct {
typedef struct UnkStruct_ov12_02226504_t {
UnkStruct_ov12_02226490 unk_00;
UnkStruct_02013B10 * unk_1C;
BufferManager * unk_1C;
u32 unk_20[192];
u32 unk_320[192];
u32 unk_620;
@ -56,7 +56,7 @@ typedef struct UnkStruct_ov12_02226504_t {
typedef struct UnkStruct_ov12_0222660C_t {
UnkStruct_ov12_02226490 unk_00;
UnkStruct_02013BE0 * unk_1C;
ScreenScrollManager * unk_1C;
} UnkStruct_ov12_0222660C;
typedef struct UnkStruct_ov12_022267D4_t {
@ -849,7 +849,7 @@ static void ov12_02226458 (SysTask * param0, void * param1)
v0->unk_0C = 1;
v0->unk_10(v0->unk_18);
} else {
sub_02013BA8();
BufferManager_StopDMA();
}
}
@ -888,7 +888,7 @@ static void ov12_022264D0 (UnkStruct_ov12_02226490 * param0)
SysTask_Done(param0->unk_00);
}
sub_02013BA8();
BufferManager_StopDMA();
}
static void ov12_022264F4 (UnkStruct_ov12_02226490 * param0)
@ -901,17 +901,17 @@ static void ov12_02226504 (UnkStruct_ov12_02226504 * param0)
{
const void * v0;
v0 = sub_02013B68(param0->unk_1C);
v0 = BufferManager_GetReadBuffer(param0->unk_1C);
sub_02013BA8();
sub_02013BB8(v0, (void *)param0->unk_620, 4, 1);
BufferManager_StopDMA();
BufferManager_StartDMA(v0, (void *)param0->unk_620, 4, 1);
}
static void ov12_02226528 (void * param0)
{
UnkStruct_ov12_02226504 * v0 = param0;
sub_02013B94(v0->unk_1C);
BufferManager_SwapBuffers(v0->unk_1C);
ov12_02226504(v0);
}
@ -929,7 +929,7 @@ UnkStruct_ov12_02226504 * ov12_02226544 (u32 param0, u32 param1, int param2)
memset(v0, 0, sizeof(UnkStruct_ov12_02226504));
GF_ASSERT(v0);
v0->unk_1C = sub_02013B10(param2, v0->unk_20, v0->unk_320);
v0->unk_1C = BufferManager_New(param2, v0->unk_20, v0->unk_320);
GF_ASSERT(v0->unk_1C);
v0->unk_620 = param0;
@ -949,7 +949,7 @@ void ov12_022265C0 (UnkStruct_ov12_02226504 * param0)
ov12_022264D0(&param0->unk_00);
if (param0->unk_1C != NULL) {
sub_02013B40(param0->unk_1C);
BufferManager_Delete(param0->unk_1C);
}
Heap_FreeToHeap(param0);
@ -958,7 +958,7 @@ void ov12_022265C0 (UnkStruct_ov12_02226504 * param0)
void * ov12_022265E4 (const UnkStruct_ov12_02226504 * param0)
{
GF_ASSERT(param0);
return sub_02013B54(param0->unk_1C);
return BufferManager_GetWriteBuffer(param0->unk_1C);
}
void ov12_022265F8 (UnkStruct_ov12_02226504 * param0)
@ -971,14 +971,14 @@ static void ov12_0222660C (void * param0)
{
UnkStruct_ov12_0222660C * v0 = param0;
sub_02013DA4(v0->unk_1C);
sub_02013DDC(v0->unk_1C);
ScreenScrollManager_SwapBuffers(v0->unk_1C);
ScreenScrollManager_RestartDMA(v0->unk_1C);
}
static void ov12_02226620 (void * param0)
{
UnkStruct_ov12_0222660C * v0 = param0;
sub_02013DDC(v0->unk_1C);
ScreenScrollManager_RestartDMA(v0->unk_1C);
}
UnkStruct_ov12_0222660C * ov12_0222662C (u8 param0, u8 param1, u16 param2, fx32 param3, s16 param4, u32 param5, u32 param6, u32 param7, int param8)
@ -994,9 +994,9 @@ UnkStruct_ov12_0222660C * ov12_0222662C (u8 param0, u8 param1, u16 param2, fx32
memset(v0, 0, sizeof(UnkStruct_ov12_0222660C));
v1 = ov12_022266F0(param5);
v0->unk_1C = sub_02013BE0(param8);
v0->unk_1C = ScreenScrollManager_New(param8);
sub_02013C10(v0->unk_1C, param0, param1, param2, param3, param4, v1, param7, param6);
ScreenScrollManager_ScrollX(v0->unk_1C, param0, param1, param2, param3, param4, v1, param7, param6);
ov12_02226490(&v0->unk_00, v0, ov12_0222660C, ov12_02226620);
return v0;
@ -1009,7 +1009,7 @@ void ov12_0222669C (UnkStruct_ov12_0222660C * param0)
ov12_022264D0(&param0->unk_00);
if (param0->unk_1C) {
sub_02013D74(param0->unk_1C);
ScreenScrollManager_Delete(param0->unk_1C);
}
Heap_FreeToHeap(param0);
@ -1018,7 +1018,7 @@ void ov12_0222669C (UnkStruct_ov12_0222660C * param0)
void * ov12_022266C0 (const UnkStruct_ov12_0222660C * param0)
{
GF_ASSERT(param0);
return sub_02013D94(param0->unk_1C);
return ScreenScrollManager_GetWriteBuffer(param0->unk_1C);
}
void ov12_022266D4 (UnkStruct_ov12_0222660C * param0)

16
src/overlay097/ov97_02230410.c
View File

@ -70,7 +70,7 @@ FS_EXTERN_OVERLAY(overlay97);
typedef struct {
u16 unk_00[2][768];
UnkStruct_02013B10 * unk_C00;
BufferManager * unk_C00;
SysTask * unk_C04;
fx32 unk_C08;
fx32 unk_C0C;
@ -854,8 +854,8 @@ static void ov97_02231290 (SysTask * param0, void * param1)
{
UnkStruct_ov97_02231318 * v0 = (UnkStruct_ov97_02231318 *)param1;
sub_02013BA8();
sub_02013BB8(sub_02013B68(v0->unk_C00), (void *)REG_BG0HOFS_ADDR, sizeof(u32) * 2, 1);
BufferManager_StopDMA();
BufferManager_StartDMA(BufferManager_GetReadBuffer(v0->unk_C00), (void *)REG_BG0HOFS_ADDR, sizeof(u32) * 2, 1);
}
static void ov97_022312B4 (UnkStruct_ov97_02230868 * param0, BOOL param1, fx32 param2, fx32 param3)
@ -867,7 +867,7 @@ static void ov97_022312B4 (UnkStruct_ov97_02230868 * param0, BOOL param1, fx32 p
v0->unk_C0C = param3;
if (v0->unk_C00 == NULL) {
v0->unk_C00 = sub_02013B10(87, v0->unk_00[0], v0->unk_00[1]);
v0->unk_C00 = BufferManager_New(87, v0->unk_00[0], v0->unk_00[1]);
}
if (v0->unk_C04 == NULL) {
@ -882,7 +882,7 @@ static void ov97_02231318 (UnkStruct_ov97_02230868 * param0)
UnkStruct_ov97_02231318 * v0 = &param0->unk_31F4;
if (v0->unk_C00) {
sub_02013B40(v0->unk_C00);
BufferManager_Delete(v0->unk_C00);
}
if (v0->unk_C04) {
@ -892,7 +892,7 @@ static void ov97_02231318 (UnkStruct_ov97_02230868 * param0)
v0->unk_C00 = NULL;
v0->unk_C04 = NULL;
sub_02013BA8();
BufferManager_StopDMA();
}
static BOOL ov97_02231354 (UnkStruct_ov97_02230868 * param0)
@ -927,7 +927,7 @@ static BOOL ov97_02231354 (UnkStruct_ov97_02230868 * param0)
}
}
v2 = sub_02013B54(v3->unk_C00);
v2 = BufferManager_GetWriteBuffer(v3->unk_C00);
for (v0 = 168 / 2; v0 < 168; v0++) {
v1 = v4 / FX32_ONE;
@ -947,7 +947,7 @@ static BOOL ov97_02231354 (UnkStruct_ov97_02230868 * param0)
}
DC_FlushRange(v2, sizeof(u16) * HW_LCD_HEIGHT * 4);
sub_02013B94(v3->unk_C00);
BufferManager_SwapBuffers(v3->unk_C00);
return 0;
}

16
src/overlay100/ov100_021D4E04.c
View File

@ -33,7 +33,7 @@ typedef struct {
typedef struct UnkStruct_ov104_0223F174_t {
UnkStruct_ov104_0223F174_sub1 unk_00;
UnkStruct_02013B10 * unk_1C;
BufferManager * unk_1C;
u32 unk_20[192];
u32 unk_320[192];
u32 unk_620;
@ -67,17 +67,17 @@ static void ov100_021D4E18 (SysTask * param0, void * param1)
UnkStruct_ov100_021D4E3C * v0 = param1;
if (v0->unk_08 >= 2) {
sub_02013DA4(v0->unk_00);
ScreenScrollManager_SwapBuffers(v0->unk_00);
v0->unk_08 = 0;
}
sub_02013DDC(v0->unk_00);
ScreenScrollManager_RestartDMA(v0->unk_00);
v0->unk_08++;
}
void ov100_021D4E3C (UnkStruct_ov100_021D4E3C * param0, u32 param1)
{
param0->unk_00 = sub_02013BE0(param1);
param0->unk_00 = ScreenScrollManager_New(param1);
param0->unk_08 = 0;
param0->unk_04 = ov100_021D4E04(param0);
}
@ -85,16 +85,16 @@ void ov100_021D4E3C (UnkStruct_ov100_021D4E3C * param0, u32 param1)
void ov100_021D4E58 (UnkStruct_ov100_021D4E3C * param0)
{
SysTask_Done(param0->unk_04);
sub_02013D38(param0->unk_00);
sub_02013D74(param0->unk_00);
ScreenScrollManager_Stop(param0->unk_00);
ScreenScrollManager_Delete(param0->unk_00);
}
void ov100_021D4E70 (UnkStruct_ov100_021D4E3C * param0, u8 param1, u8 param2, u16 param3, fx32 param4, s16 param5, u32 param6, u32 param7, u32 param8, int param9)
{
if (param9 == 0) {
sub_02013C10(param0->unk_00, param1, param2, param3, param4, param5, param6, param7, param8);
ScreenScrollManager_ScrollX(param0->unk_00, param1, param2, param3, param4, param5, param6, param7, param8);
} else {
sub_02013CA4(param0->unk_00, param1, param2, param3, param4, param5, param6, param7, param8);
ScreenScrollManager_ScrollY(param0->unk_00, param1, param2, param3, param4, param5, param6, param7, param8);
}
}

28
src/overlay104/ov104_0223E894.c
View File

@ -68,7 +68,7 @@ typedef struct {
typedef struct UnkStruct_ov104_0223F174_t {
UnkStruct_ov104_0223F0D8 unk_00;
UnkStruct_02013B10 * unk_1C;
BufferManager * unk_1C;
UnkStruct_ov104_0223F1B4 unk_20[192];
UnkStruct_ov104_0223F1B4 unk_1820[192];
u32 unk_3020;
@ -507,24 +507,24 @@ static void ov104_0223F070 (SysTask * param0, void * param1)
UnkStruct_ov104_0223F094 * v0 = param1;
if (v0->unk_08 >= 2) {
sub_02013DA4(v0->unk_00);
ScreenScrollManager_SwapBuffers(v0->unk_00);
v0->unk_08 = 0;
}
sub_02013DDC(v0->unk_00);
ScreenScrollManager_RestartDMA(v0->unk_00);
v0->unk_08++;
}
void ov104_0223F094 (UnkStruct_ov104_0223F094 * param0, u32 param1)
{
param0->unk_00 = sub_02013BE0(param1);
param0->unk_00 = ScreenScrollManager_New(param1);
param0->unk_08 = 0;
param0->unk_04 = ov104_0223F05C(param0);
}
void ov104_0223F0B0 (UnkStruct_ov104_0223F094 * param0, u8 param1, u8 param2, u16 param3, fx32 param4, s16 param5, u32 param6, u32 param7, u32 param8)
{
sub_02013C10(param0->unk_00, param1, param2, param3, param4, param5, param6, param7, param8);
ScreenScrollManager_ScrollX(param0->unk_00, param1, param2, param3, param4, param5, param6, param7, param8);
}
static void ov104_0223F0D8 (SysTask * param0, void * param1)
@ -536,7 +536,7 @@ static void ov104_0223F0D8 (SysTask * param0, void * param1)
v0->unk_10(v0->unk_18);
} else {
sub_02013BA8();
BufferManager_StopDMA();
}
}
@ -576,24 +576,24 @@ static void ov104_0223F150 (UnkStruct_ov104_0223F0D8 * param0)
SysTask_Done(param0->unk_00);
}
sub_02013BA8();
BufferManager_StopDMA();
}
static void ov104_0223F174 (UnkStruct_ov104_0223F174 * param0)
{
const void * v0;
v0 = sub_02013B68(param0->unk_1C);
v0 = BufferManager_GetReadBuffer(param0->unk_1C);
sub_02013BA8();
sub_02013BB8(v0, (void *)param0->unk_3020, (sizeof(UnkStruct_ov104_0223F1B4)), 1);
BufferManager_StopDMA();
BufferManager_StartDMA(v0, (void *)param0->unk_3020, (sizeof(UnkStruct_ov104_0223F1B4)), 1);
}
static void ov104_0223F198 (void * param0)
{
UnkStruct_ov104_0223F174 * v0 = param0;
sub_02013B94(v0->unk_1C);
BufferManager_SwapBuffers(v0->unk_1C);
ov104_0223F174(v0);
}
@ -612,7 +612,7 @@ UnkStruct_ov104_0223F174 * ov104_0223F1B4 (u32 param0, UnkStruct_ov104_0223F1B4
memset(v0, 0, sizeof(UnkStruct_ov104_0223F174));
GF_ASSERT(v0);
v0->unk_1C = sub_02013B10(param2, v0->unk_20, v0->unk_1820);
v0->unk_1C = BufferManager_New(param2, v0->unk_20, v0->unk_1820);
GF_ASSERT(v0->unk_1C);
v0->unk_3020 = param0;
@ -633,7 +633,7 @@ void ov104_0223F258 (UnkStruct_ov104_0223F174 * param0)
ov104_0223F150(&param0->unk_00);
if (param0->unk_1C != NULL) {
sub_02013B40(param0->unk_1C);
BufferManager_Delete(param0->unk_1C);
}
Heap_FreeToHeap(param0);
@ -643,5 +643,5 @@ void * ov104_0223F27C (const UnkStruct_ov104_0223F174 * param0)
{
GF_ASSERT(param0);
return sub_02013B54(param0->unk_1C);
return BufferManager_GetWriteBuffer(param0->unk_1C);
}

18
src/overlay114/ov114_0225C700.c
View File

@ -163,7 +163,7 @@ typedef struct {
typedef struct {
UnkStruct_ov114_0225CEF0 * unk_00;
s16 unk_04[2][192];
UnkStruct_02013B10 * unk_304;
BufferManager * unk_304;
} UnkStruct_ov114_0225DFFC;
typedef struct UnkStruct_ov114_0225D678_t {
@ -2188,9 +2188,9 @@ static void ov114_0225DF7C (UnkStruct_ov114_0225DFFC * param0, UnkStruct_ov114_0
MI_CpuFill16(&param0->unk_04[v0], -255, sizeof(s16) * 192);
}
param0->unk_304 = sub_02013B10(param2, &param0->unk_04[0], &param0->unk_04[1]);
param0->unk_304 = BufferManager_New(param2, &param0->unk_04[0], &param0->unk_04[1]);
sub_02013B80(param0->unk_304, 0);
BufferManager_SetMode(param0->unk_304, 0);
SetHBlankCallback(ov114_0225E0AC, param0);
}
@ -2198,7 +2198,7 @@ static void ov114_0225DFFC (UnkStruct_ov114_0225DFFC * param0)
{
if (param0->unk_304 != NULL) {
SetHBlankCallback(NULL, NULL);
sub_02013B40(param0->unk_304);
BufferManager_Delete(param0->unk_304);
param0->unk_304 = NULL;
}
}
@ -2211,7 +2211,7 @@ static void ov114_0225E028 (UnkStruct_ov114_0225DFFC * param0, const UnkStruct_o
GF_ASSERT(param0->unk_304 != NULL);
v0 = sub_02013B54(param0->unk_304);
v0 = BufferManager_GetWriteBuffer(param0->unk_304);
for (v1 = 0; v1 < 6 * 8; v1++) {
v2 = v1 - 1;
@ -2224,7 +2224,7 @@ static void ov114_0225E028 (UnkStruct_ov114_0225DFFC * param0, const UnkStruct_o
v0[v2] = param1->unk_1C.unk_00 >> FX32_SHIFT;
}
sub_02013B80(param0->unk_304, 1);
BufferManager_SetMode(param0->unk_304, 1);
}
static void ov114_0225E08C (UnkStruct_ov114_0225DFFC * param0)
@ -2233,8 +2233,8 @@ static void ov114_0225E08C (UnkStruct_ov114_0225DFFC * param0)
return;
}
sub_02013B94(param0->unk_304);
sub_02013B80(param0->unk_304, 0);
BufferManager_SwapBuffers(param0->unk_304);
BufferManager_SetMode(param0->unk_304, 0);
}
static void ov114_0225E0AC (void * param0)
@ -2249,7 +2249,7 @@ static void ov114_0225E0AC (void * param0)
return;
}
v2 = sub_02013B68(v0->unk_304);
v2 = BufferManager_GetReadBuffer(v0->unk_304);
if (GX_IsHBlank()) {
sub_02019184(v0->unk_00->unk_00, 0, 0, v2[v1]);

338
src/unk_02013B10.c
View File

@ -1,303 +1,299 @@
#include <nitro.h>
#include <string.h>
#include "constants/heap.h"
#include "struct_decls/sys_task.h"
#include "unk_0200D9E8.h"
#include "unk_02013B10.h"
#include "heap.h"
typedef struct UnkStruct_02013B10_t {
void * unk_00[2];
u8 unk_08;
u8 unk_09;
u8 unk_0A[2];
} UnkStruct_02013B10;
typedef struct BufferManager {
void *buffers[2];
u8 writeBuffer;
u8 mode;
u8 padding[2];
} BufferManager;
typedef struct UnkStruct_02013BE0_t {
u32 unk_00[192];
u32 unk_300[192];
UnkStruct_02013B10 * unk_600;
SysTask * unk_604;
BOOL unk_608;
s16 unk_60C[192];
u8 unk_78C;
u8 unk_78D;
u32 unk_790;
u32 unk_794;
s16 unk_798;
s16 unk_79A;
} UnkStruct_02013BE0;
typedef struct ScreenScrollManager {
u32 buffer1[SCREEN_SCROLL_MANAGER_BUFFER_SIZE];
u32 buffer2[SCREEN_SCROLL_MANAGER_BUFFER_SIZE];
BufferManager *bufferManager;
SysTask *scrollTask;
BOOL unused;
s16 sineTable[SCREEN_SCROLL_MANAGER_BUFFER_SIZE];
u8 start;
u8 end;
u32 offsetRegisterAddr;
u32 initValue;
s16 scrollPos;
s16 scrollSpeed;
} ScreenScrollManager;
static void sub_02013FC8(void);
static void sub_02013FD0(const UnkStruct_02013BE0 * param0);
static void sub_02013E58(SysTask * param0, void * param1);
static void sub_02013F04(SysTask * param0, void * param1);
static void ScreenScrollManager_StopDMA(void);
static void ScreenScrollManager_StartDMA(const ScreenScrollManager *screenScrollMgr);
static void ScreenScrollManager_UpdateScrollX(SysTask *task, void *param);
static void ScreenScrollManager_UpdateScrollY(SysTask *task, void *param);
UnkStruct_02013B10 * sub_02013B10 (int param0, void * param1, void * param2)
BufferManager *BufferManager_New(enum HeapId heapID, void *buffer1, void *buffer2)
{
UnkStruct_02013B10 * v0;
BufferManager *bufferManager = Heap_AllocFromHeap(heapID, sizeof(BufferManager));
memset(bufferManager, 0, sizeof(BufferManager));
v0 = Heap_AllocFromHeap(param0, sizeof(UnkStruct_02013B10));
memset(v0, 0, sizeof(UnkStruct_02013B10));
bufferManager->mode = BUFFER_MANAGER_MODE_DOUBLE;
bufferManager->buffers[0] = buffer1;
bufferManager->buffers[1] = buffer2;
v0->unk_09 = 1;
v0->unk_00[0] = param1;
v0->unk_00[1] = param2;
return v0;
return bufferManager;
}
void sub_02013B40 (UnkStruct_02013B10 * param0)
void BufferManager_Delete(BufferManager *bufferManager)
{
GF_ASSERT(param0);
GF_ASSERT(bufferManager);
Heap_FreeToHeap(param0);
param0 = NULL;
Heap_FreeToHeap(bufferManager);
bufferManager = NULL;
}
void * sub_02013B54 (const UnkStruct_02013B10 * param0)
void *BufferManager_GetWriteBuffer(const BufferManager *bufferManager)
{
GF_ASSERT(param0);
return param0->unk_00[param0->unk_08];
GF_ASSERT(bufferManager);
return bufferManager->buffers[bufferManager->writeBuffer];
}
const void * sub_02013B68 (const UnkStruct_02013B10 * param0)
const void *BufferManager_GetReadBuffer(const BufferManager *bufferManager)
{
GF_ASSERT(param0);
return param0->unk_00[param0->unk_08 ^ 1];
GF_ASSERT(bufferManager);
return bufferManager->buffers[bufferManager->writeBuffer ^ 1];
}
void sub_02013B80 (UnkStruct_02013B10 * param0, u8 param1)
// mode can be either BUFFER_MANAGER_MODE_SINGLE or BUFFER_MANAGER_MODE_DOUBLE
void BufferManager_SetMode(BufferManager *bufferManager, u8 mode)
{
GF_ASSERT(param0);
param0->unk_09 = param1;
GF_ASSERT(bufferManager);
bufferManager->mode = mode;
}
void sub_02013B94 (UnkStruct_02013B10 * param0)
void BufferManager_SwapBuffers(BufferManager *bufferManager)
{
if (param0 == NULL) {
if (bufferManager == NULL) {
return;
}
if (param0->unk_09 == 0) {
if (bufferManager->mode == BUFFER_MANAGER_MODE_SINGLE) {
return;
}
param0->unk_08 ^= 1;
bufferManager->writeBuffer ^= 1;
}
void sub_02013BA8 (void)
void BufferManager_StopDMA(void)
{
MI_StopDma(0);
MI_WaitDma(0);
}
void sub_02013BB8 (const void * param0, void * param1, int param2, int param3)
void BufferManager_StartDMA(const void *src, void *dst, int size, enum BufferManagerDMAType dmaType)
{
if (param3 == 1) {
MI_HBlankDmaCopy32(0, param0, param1, param2);
if (dmaType == BUFFER_MANAGER_DMA_TYPE_32BIT) {
MI_HBlankDmaCopy32(0, src, dst, size);
} else {
MI_HBlankDmaCopy16(0, param0, param1, param2);
MI_HBlankDmaCopy16(0, src, dst, size);
}
}
UnkStruct_02013BE0 * sub_02013BE0 (int param0)
ScreenScrollManager *ScreenScrollManager_New(enum HeapId heapID)
{
UnkStruct_02013BE0 * v0;
ScreenScrollManager *screenScrollMgr = Heap_AllocFromHeap(heapID, sizeof(ScreenScrollManager));
memset(screenScrollMgr, 0, sizeof(ScreenScrollManager));
screenScrollMgr->bufferManager = BufferManager_New(heapID, screenScrollMgr->buffer1, screenScrollMgr->buffer2);
v0 = Heap_AllocFromHeap(param0, sizeof(UnkStruct_02013BE0));
memset(v0, 0, sizeof(UnkStruct_02013BE0));
v0->unk_600 = sub_02013B10(param0, v0->unk_00, v0->unk_300);
return v0;
return screenScrollMgr;
}
void sub_02013C10 (UnkStruct_02013BE0 * param0, u8 param1, u8 param2, u16 param3, fx32 param4, s16 param5, u32 param6, u32 param7, u32 param8)
void ScreenScrollManager_ScrollX(ScreenScrollManager *screenScrollMgr, u8 start, u8 end, u16 angleIncrement, fx32 amplitude, s16 speed, u32 bg, u32 initValue, u32 priority)
{
GF_ASSERT(param0);
GF_ASSERT(param0->unk_604 == NULL);
GF_ASSERT(screenScrollMgr);
GF_ASSERT(screenScrollMgr->scrollTask == NULL);
param0->unk_78C = param1;
param0->unk_78D = param2;
param0->unk_798 = 0;
param0->unk_79A = param5;
param0->unk_790 = param6;
param0->unk_794 = param7;
screenScrollMgr->start = start;
screenScrollMgr->end = end;
screenScrollMgr->scrollPos = 0;
screenScrollMgr->scrollSpeed = speed;
screenScrollMgr->offsetRegisterAddr = bg;
screenScrollMgr->initValue = initValue;
sub_02013DFC(param0->unk_60C, 192, param3, param4);
ScreenScrollManager_CreateSineTable(screenScrollMgr->sineTable, SCREEN_SCROLL_MANAGER_BUFFER_SIZE, angleIncrement, amplitude);
param0->unk_604 = SysTask_Start(sub_02013E58, param0, param8);
screenScrollMgr->scrollTask = SysTask_Start(ScreenScrollManager_UpdateScrollX, screenScrollMgr, priority);
MI_CpuFill32(param0->unk_00, param0->unk_794, sizeof(u32) * 192);
MI_CpuFill32(param0->unk_300, param0->unk_794, sizeof(u32) * 192);
MI_CpuFill32(screenScrollMgr->buffer1, screenScrollMgr->initValue, sizeof(u32) * SCREEN_SCROLL_MANAGER_BUFFER_SIZE);
MI_CpuFill32(screenScrollMgr->buffer2, screenScrollMgr->initValue, sizeof(u32) * SCREEN_SCROLL_MANAGER_BUFFER_SIZE);
}
void sub_02013CA4 (UnkStruct_02013BE0 * param0, u8 param1, u8 param2, u16 param3, fx32 param4, s16 param5, u32 param6, u32 param7, u32 param8)
void ScreenScrollManager_ScrollY(ScreenScrollManager *screenScrollMgr, u8 start, u8 end, u16 angleIncrement, fx32 amplitude, s16 speed, u32 bg, u32 initValue, u32 priority)
{
GF_ASSERT(param0);
GF_ASSERT(param0->unk_604 == NULL);
GF_ASSERT(screenScrollMgr);
GF_ASSERT(screenScrollMgr->scrollTask == NULL);
param0->unk_78C = param1;
param0->unk_78D = param2;
param0->unk_798 = 0;
param0->unk_79A = param5;
param0->unk_790 = param6;
param0->unk_794 = param7;
screenScrollMgr->start = start;
screenScrollMgr->end = end;
screenScrollMgr->scrollPos = 0;
screenScrollMgr->scrollSpeed = speed;
screenScrollMgr->offsetRegisterAddr = bg;
screenScrollMgr->initValue = initValue;
sub_02013DFC(param0->unk_60C, 192, param3, param4);
ScreenScrollManager_CreateSineTable(screenScrollMgr->sineTable, SCREEN_SCROLL_MANAGER_BUFFER_SIZE, angleIncrement, amplitude);
param0->unk_604 = SysTask_Start(sub_02013F04, param0, param8);
screenScrollMgr->scrollTask = SysTask_Start(ScreenScrollManager_UpdateScrollY, screenScrollMgr, priority);
MI_CpuFill32(param0->unk_00, param0->unk_794, sizeof(u32) * 192);
MI_CpuFill32(param0->unk_300, param0->unk_794, sizeof(u32) * 192);
MI_CpuFill32(screenScrollMgr->buffer1, screenScrollMgr->initValue, sizeof(u32) * SCREEN_SCROLL_MANAGER_BUFFER_SIZE);
MI_CpuFill32(screenScrollMgr->buffer2, screenScrollMgr->initValue, sizeof(u32) * SCREEN_SCROLL_MANAGER_BUFFER_SIZE);
}
void sub_02013D38 (UnkStruct_02013BE0 * param0)
void ScreenScrollManager_Stop(ScreenScrollManager *screenScrollMgr)
{
void * v0;
void *writeBuffer;
GF_ASSERT(param0);
GF_ASSERT(screenScrollMgr);
if (param0->unk_604) {
SysTask_Done(param0->unk_604);
param0->unk_604 = NULL;
if (screenScrollMgr->scrollTask) {
SysTask_Done(screenScrollMgr->scrollTask);
screenScrollMgr->scrollTask = NULL;
v0 = sub_02013B54(param0->unk_600);
memset(v0, param0->unk_794, sizeof(u32) * 192);
writeBuffer = BufferManager_GetWriteBuffer(screenScrollMgr->bufferManager);
memset(writeBuffer, screenScrollMgr->initValue, sizeof(u32) * SCREEN_SCROLL_MANAGER_BUFFER_SIZE);
}
}
void sub_02013D74 (UnkStruct_02013BE0 * param0)
void ScreenScrollManager_Delete(ScreenScrollManager *screenScrollMgr)
{
sub_02013D38(param0);
sub_02013FC8();
sub_02013B40(param0->unk_600);
Heap_FreeToHeap(param0);
ScreenScrollManager_Stop(screenScrollMgr);
ScreenScrollManager_StopDMA();
BufferManager_Delete(screenScrollMgr->bufferManager);
Heap_FreeToHeap(screenScrollMgr);
}
void * sub_02013D94 (UnkStruct_02013BE0 * param0)
void *ScreenScrollManager_GetWriteBuffer(ScreenScrollManager *screenScrollMgr)
{
return sub_02013B54(param0->unk_600);
return BufferManager_GetWriteBuffer(screenScrollMgr->bufferManager);
}
void sub_02013DA4 (UnkStruct_02013BE0 * param0)
void ScreenScrollManager_SwapBuffers(ScreenScrollManager *screenScrollMgr)
{
void * v0;
void *writeBuffer;
if (param0 == NULL) {
if (screenScrollMgr == NULL) {
return;
}
if (param0->unk_604) {
sub_02013B94(param0->unk_600);
if (screenScrollMgr->scrollTask) {
BufferManager_SwapBuffers(screenScrollMgr->bufferManager);
v0 = sub_02013B54(param0->unk_600);
MI_CpuFill32(v0, param0->unk_794, sizeof(u32) * 192);
writeBuffer = BufferManager_GetWriteBuffer(screenScrollMgr->bufferManager);
MI_CpuFill32(writeBuffer, screenScrollMgr->initValue, sizeof(u32) * SCREEN_SCROLL_MANAGER_BUFFER_SIZE);
}
}
void sub_02013DDC (UnkStruct_02013BE0 * param0)
void ScreenScrollManager_RestartDMA(ScreenScrollManager *screenScrollMgr)
{
if (param0 == NULL) {
if (screenScrollMgr == NULL) {
return;
}
if (param0->unk_604) {
sub_02013FC8();
sub_02013FD0(param0);
if (screenScrollMgr->scrollTask) {
ScreenScrollManager_StopDMA();
ScreenScrollManager_StartDMA(screenScrollMgr);
}
}
void sub_02013DFC (s16 * param0, u32 param1, u16 param2, fx32 param3)
void ScreenScrollManager_CreateSineTable(s16 *dest, u32 entryCount, u16 angleIncrement, fx32 amplitude)
{
int v0;
u16 v1;
int i;
u16 angle = 0;
v1 = 0;
for (v0 = 0; v0 < param1; v0++) {
param0[v0] = FX_Mul(FX_SinIdx(v1), param3) >> FX32_SHIFT;
v1 += param2;
for (i = 0; i < entryCount; i++) {
dest[i] = FX_Mul(FX_SinIdx(angle), amplitude) >> FX32_SHIFT;
angle += angleIncrement;
}
}
static void sub_02013E58 (SysTask * param0, void * param1)
static void ScreenScrollManager_UpdateScrollX(SysTask *task, void *param)
{
UnkStruct_02013BE0 * v0 = param1;
int v1;
u32 * v2;
u8 v3;
s16 v4;
u16 v5;
ScreenScrollManager *screenScrollMgr = param;
int i;
u32 *writeBuffer;
u8 scrollPos;
s16 xOff;
u16 yOff;
v2 = sub_02013B54(v0->unk_600);
v3 = v0->unk_798 / 100;
writeBuffer = BufferManager_GetWriteBuffer(screenScrollMgr->bufferManager);
scrollPos = screenScrollMgr->scrollPos / SCREEN_SCROLL_MANAGER_SCALING_FACTOR;
for (v1 = v0->unk_78C; v1 <= v0->unk_78D; v1++) {
v4 = v2[v1] & 0xffff;
v5 = v2[v1] >> 16;
for (i = screenScrollMgr->start; i <= screenScrollMgr->end; i++) {
xOff = writeBuffer[i] & 0xffff;
yOff = writeBuffer[i] >> 16;
v4 += v0->unk_60C[v3];
v2[v1] = (v5 << 16) | (v4 & 0xffff);
v3 = (v3 + 1) % 192;
xOff += screenScrollMgr->sineTable[scrollPos];
writeBuffer[i] = (yOff << 16) | (xOff & 0xffff);
scrollPos = (scrollPos + 1) % SCREEN_SCROLL_MANAGER_BUFFER_SIZE;
}
v0->unk_798 += v0->unk_79A;
screenScrollMgr->scrollPos += screenScrollMgr->scrollSpeed;
if (v0->unk_798 >= (192 * 100)) {
v0->unk_798 %= (192 * 100);
if (screenScrollMgr->scrollPos >= SCREEN_SCROLL_MANAGER_MAX_SCROLL) {
screenScrollMgr->scrollPos %= SCREEN_SCROLL_MANAGER_MAX_SCROLL;
} else {
if (v0->unk_798 < 0) {
v0->unk_798 += (192 * 100);
if (screenScrollMgr->scrollPos < 0) {
screenScrollMgr->scrollPos += SCREEN_SCROLL_MANAGER_MAX_SCROLL;
}
}
}
static void sub_02013F04 (SysTask * param0, void * param1)
static void ScreenScrollManager_UpdateScrollY(SysTask *task, void *param)
{
UnkStruct_02013BE0 * v0 = param1;
int v1;
u32 * v2;
u8 v3;
s16 v4;
u16 v5;
ScreenScrollManager *screenScrollMgr = param;
int i;
u32 *writeBuffer;
u8 scrollPos;
s16 xOff;
u16 yOff;
v2 = sub_02013B54(v0->unk_600);
v3 = v0->unk_798 / 100;
writeBuffer = BufferManager_GetWriteBuffer(screenScrollMgr->bufferManager);
scrollPos = screenScrollMgr->scrollPos / SCREEN_SCROLL_MANAGER_SCALING_FACTOR;
for (v1 = v0->unk_78C; v1 <= v0->unk_78D; v1++) {
v4 = v2[v1] & 0xffff;
v5 = v2[v1] >> 16;
for (i = screenScrollMgr->start; i <= screenScrollMgr->end; i++) {
xOff = writeBuffer[i] & 0xffff;
yOff = writeBuffer[i] >> 16;
v5 += v0->unk_60C[(v3 + 180) % 192];
v2[v1] = (v5 << 16) | (v4 & 0xffff);
v3 = (v3 + 1) % 192;
yOff += screenScrollMgr->sineTable[(scrollPos + 180) % SCREEN_SCROLL_MANAGER_BUFFER_SIZE];
writeBuffer[i] = (yOff << 16) | (xOff & 0xffff);
scrollPos = (scrollPos + 1) % SCREEN_SCROLL_MANAGER_BUFFER_SIZE;
}
v0->unk_798 += v0->unk_79A;
screenScrollMgr->scrollPos += screenScrollMgr->scrollSpeed;
if (v0->unk_798 >= (192 * 100)) {
v0->unk_798 %= (192 * 100);
if (screenScrollMgr->scrollPos >= SCREEN_SCROLL_MANAGER_MAX_SCROLL) {
screenScrollMgr->scrollPos %= SCREEN_SCROLL_MANAGER_MAX_SCROLL;
} else {
if (v0->unk_798 < 0) {
v0->unk_798 += (192 * 100);
if (screenScrollMgr->scrollPos < 0) {
screenScrollMgr->scrollPos += SCREEN_SCROLL_MANAGER_MAX_SCROLL;
}
}
}
void sub_02013FC8 (void)
void ScreenScrollManager_StopDMA(void)
{
sub_02013BA8();
BufferManager_StopDMA();
}
void sub_02013FD0 (const UnkStruct_02013BE0 * param0)
void ScreenScrollManager_StartDMA(const ScreenScrollManager *screenScrollManager)
{
const void * v0;
const void *readBuffer;
GF_ASSERT(param0);
v0 = sub_02013B68(param0->unk_600);
DC_FlushRange(v0, sizeof(u32) * 192);
GF_ASSERT(screenScrollManager);
readBuffer = BufferManager_GetReadBuffer(screenScrollManager->bufferManager);
DC_FlushRange(readBuffer, sizeof(u32) * SCREEN_SCROLL_MANAGER_BUFFER_SIZE);
sub_02013BB8(v0, (void *)param0->unk_790, sizeof(u32), 1);
BufferManager_StartDMA(readBuffer, (void *)screenScrollManager->offsetRegisterAddr, sizeof(u32), BUFFER_MANAGER_DMA_TYPE_32BIT);
}