Compare commits

...

20 Commits

Author SHA1 Message Date
coah
19a013e64a add SDChannelSelect state/worker accessors used by iplSDMemory 2026-09-29 09:21:07 +00:00
coah
44fd31e660 sdmemory: carry over worker delta (sd channel select header changes left out) 2026-09-29 09:14:24 +00:00
coah
ac51d83fa5 iplSetting: 78/112 functions (worker 3adbf457) (#259) 2026-09-29 04:14:07 -05:00
coah
6490b90f65 Decompile PrFILE2 pf_volume to 6/37 functions (worker 0686f984) (#258) 2026-09-29 04:13:13 -05:00
coah
823ee31937 Decompile PrFILE2 pf_file to 23/45 functions (worker 90e4121e) (#257) 2026-09-29 04:11:22 -05:00
coah
51f940c1ea Decompile iplSetting to 68/112 functions (#256)
* start decompiling setting scene

* match basic setting scene helpers

* match setting constructor and storage

* match setting lookup helpers

* match setting cleanup methods

* restore setting scene name tables

* match setting fadein state copy

* decompile setting screen transitions

* match setting video mode transition

* decompile setting normal update

* decompile setting fadeout

* match setting data initialization

* decompile setting input initialization

* decompile setting access point flow

* decompile setting network workflows

* match setting helper frames

* match setting update initialization

* match setting eula initialization

* match setting fadein readiness

* type setting helper allocations

* localize browser setting tables

* match setting controller flow

* match setting exit condition

* improve setting screen mode flow

* match setting normal state cases

* improve setting keyboard initialization

* match setting text input handling

* match setting ssid initialization

* match setting address initialization

* match setting proxy initialization

* match setting nickname save

* match setting security and ssid writes

* match setting proxy profile updates

* match setting mtu parsing

* match parental password results

* match parental security answer result

* match master key result order

* improve setting text validation

* implement setting reverse ip conversion

* type setting text buffer as wide characters

* match setting default back string

* improve setting safe mode match

* match setting access point reset

* match setting access point redraw

* match setting access point events

* match setting left event

* improve setting creation and AP traversal
2026-09-29 01:28:56 -05:00
coah
8e254f1c88 wad: refine import/backup paths (21/40) (#255) 2026-09-29 00:39:13 -05:00
coah
313e396989 sdmemory: continue decompilation (worker snapshot d94f5e95) (#254) 2026-09-28 23:57:13 -05:00
coah
f98e550b24 sdchansel: continue decompilation (worker snapshot b063d97f) (#253) 2026-09-28 23:57:07 -05:00
coah
7f8b4c8a4f wad: continue decompilation (worker snapshot f33bf397) (#252) 2026-09-28 23:57:01 -05:00
devin-ai-integration[bot]
6806dc1926 net: link nettime (genuine implementation, objdiff 100%) (#251)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-29 04:39:06 +00:00
coah
f0f1462ff4 match pf dir handle checks (#250) 2026-09-28 23:05:09 -05:00
coah
9347e0b1c3 Decompile iplSDMemory to 22/66 functions (#249)
* decompile SD memory setup helpers

* match SD memory arrow helpers

* match sd memory setup helpers

* decompile sd memory dialog reset

* order sd memory text pane updates

* match sd memory calculation

* decompile sd memory dialog states
2026-09-28 22:53:23 -05:00
coah
341ce036f5 Decompile iplSDChannelSelect to 42/129 functions (#248)
* start sd channel select decompilation

* add sd channel layouts and drawing

* match sd worker state helpers

* match nand title count handling

* name sd channel scene helpers

* match sd worker completion handlers

* match channel visibility lookup

* match channel queue helpers

* fix sd command notice payloads

* align sd worker state dispatch

* match sd channel object destruction

* match visible channel drawing passes

* match sd channel layout updates

* match sd channel pane helpers

* match page animation calculation
2026-09-28 22:53:07 -05:00
coah
53be96c012 Decompile PrFILE2 pf_dir to 20/38 functions (#247)
* decompile pf_dir empty check

* decompile pf_dir path handling

* decompile pf_dir attribute and remove paths

* decompile pf_dir fstat lookup

* align pf dir metadata layouts

* match pf dir wrappers

* decompile pf dir fsexec paths

* tune pf dir open scan

* match pf dir slot scan

* match pf dir handler close

* match pf dir finalization loop

* track free directory slot separately

* align directory position error paths

* align pf dir open path cases

* match pf dir fsexec name helpers

* match pf dir readdir loop
2026-09-28 22:51:32 -05:00
coah
a4e7841498 Decompile RVL SDK wad to 16/40 functions (#246)
* decompile wad import check

* decompile wad stream helpers

* match wad unpack routines

* match wad termination scan

* decompile backup WAD header

* decompile WAD unpack formats

* decompile wad export worker

* refine content index scan

* decompile WAD signature verification

* decompile wad hash path

* match savedata validation

* match wad title metadata query

* match BroadOn unpack offsets

* tune WAD export chunk comparison

* reuse WAD content index offsets

* tune WAD hash chunk comparison

* tune WAD content index lookup

* match WAD transfer metadata helpers

* refine WAD allocator dispatch

* refine WAD stream dispatch

* decompile WAD import dispatch

* decompile WAD backup helpers

* refine WAD savedata verification

* decompile WAD DVD boot import

* decompile WAD DVD title import

* refine WAD DVD stream parsing

* match WAD memory free

* match WAD allocator and content checks
2026-09-28 22:49:34 -05:00
devin-ai-integration[bot]
fb81577a0f Link fa/pf_api_util + pf_w_api_util (clean subset) (#245)
* fa: link pf_api_util + pf_w_api_util (genuine implementations, objdiff 100%)

Co-Authored-By: wch <usernamecole7@gmail.com>

* configure: flip fa/pf_api_util + fa/pf_w_api_util to Matching

Co-Authored-By: wch <usernamecole7@gmail.com>

---------

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-29 01:44:43 +00:00
coah
258f4a6f91 iplAddressEdit: 77/94 functions, no inline asm left (#244)
* remove stale address edit externs

* use keyboard input form member

* use nigaoe name member

* decompile address edit fade-in

* decompile address edit normal init

* decompile address edit fadeout init

* decompile address edit common calc

* decompile address edit normal state

* decompile delete message fade-in

* decompile friend info removal

* decompile delete result transition

* decompile delete result state

* decompile input wait fade-in

* decompile input normal state

* decompile address edit draw

* model string owner pointer

* decompile friend code formatting

* decompile duplicate friend code check

* decompile own friend code check

* decompile Wii ID formatting

* decompile address edit fadeout

* decompile address edit button fade-in

* remove stale address edit symbols

* match address edit event dispatch

* simplify address edit pane access

* match address edit decision animations

* match address edit event dispatch

* match address edit button fadeout

* match address edit delete animation

* match address edit mii fadeout

* simplify address edit state handlers

* simplify address edit state dispatch

* simplify address edit scene creation
2026-09-28 19:31:31 -05:00
coah
b719ba47a5 Decompile KPAD to 11/29 functions (#243)
* decompile kpad unit

* model kpad sample fields

* refine kpad ring buffer matching

* restore kpad sample history processing

* match kpad sampling branches

* restore probe callback branch

* refine kpad acceleration clamps

* refine kpad first object selection

* match kpad object candidate loops

* match kpad pointer based dpd scans

* preserve dpd sample words

* align kpad device sample handling

* refine kpad acceleration format dispatch

* match kpad init ring defaults

* align kpad init field order

* match kpad probe type dispatch

* align kpad horizon calculation order

* clean kpad field names and match repeat setup

* name kpad calibration fields

* match kpad ring buffer traversal

* refine kpad ring buffer matching
2026-09-28 19:05:02 -05:00
coah
094cfd811e Link iplController and iplControllerManager (#242)
* link iplController translation unit

* match controller manager read flow

* link iplControllerManager translation unit
2026-09-28 18:56:01 -05:00
32 changed files with 20060 additions and 1011 deletions

View File

@@ -4558,44 +4558,44 @@ __ct__Q33ipl5scene15SDChannelSelectFPQ23EGG4Heap = .text:0x813DAB08; // type:fun
__dt__Q33ipl5scene15SDChannelSelectFv = .text:0x813DAE7C; // type:function size:0x5C
prepare__Q33ipl5scene15SDChannelSelectFv = .text:0x813DAED8; // type:function size:0xA8
create__Q33ipl5scene15SDChannelSelectFv = .text:0x813DAF80; // type:function size:0x248
iplSDChannelSelect_813DB1C8 = .text:0x813DB1C8; // type:function size:0x44
iplSDChannelSelect_813DB20C = .text:0x813DB20C; // type:function size:0x48
iplSDChannelSelect_813DB254 = .text:0x813DB254; // type:function size:0xB4
iplSDChannelSelect_813DB308 = .text:0x813DB308; // type:function size:0x5C
iplSDChannelSelect_813DB364 = .text:0x813DB364; // type:function size:0x5C
iplSDChannelSelect_813DB3C0 = .text:0x813DB3C0; // type:function size:0x5C
iplSDChannelSelect_813DB41C = .text:0x813DB41C; // type:function size:0x5C
iplSDChannelSelect_813DB478 = .text:0x813DB478; // type:function size:0x5C
iplSDChannelSelect_813DB4D4 = .text:0x813DB4D4; // type:function size:0x5C
iplSDChannelSelect_813DB530 = .text:0x813DB530; // type:function size:0x5C
iplSDChannelSelect_813DB58C = .text:0x813DB58C; // type:function size:0x60
iplSDChannelSelect_813DB5EC = .text:0x813DB5EC; // type:function size:0x60
iplSDChannelSelect_813DB64C = .text:0x813DB64C; // type:function size:0x40
iplSDChannelSelect_813DB68C = .text:0x813DB68C; // type:function size:0x40
iplSDChannelSelect_813DB6CC = .text:0x813DB6CC; // type:function size:0x518
iplSDChannelSelect_813DBBE4 = .text:0x813DBBE4; // type:function size:0xB0
iplSDChannelSelect_813DBC94 = .text:0x813DBC94; // type:function size:0xB8
iplSDChannelSelect_813DBD4C = .text:0x813DBD4C; // type:function size:0x48
iplSDChannelSelect_813DBD94 = .text:0x813DBD94; // type:function size:0xD8
iplSDChannelSelect_813DBE6C = .text:0x813DBE6C; // type:function size:0x28
iplSDChannelSelect_813DBE94 = .text:0x813DBE94; // type:function size:0x124
iplSDChannelSelect_813DBFB8 = .text:0x813DBFB8; // type:function size:0x28
iplSDChannelSelect_813DBFE0 = .text:0x813DBFE0; // type:function size:0x2AC
iplSDChannelSelect_813DC28C = .text:0x813DC28C; // type:function size:0x64
iplSDChannelSelect_813DC2F0 = .text:0x813DC2F0; // type:function size:0x1B0
iplSDChannelSelect_813DC4A0 = .text:0x813DC4A0; // type:function size:0x5C
iplSDChannelSelect_813DC4FC = .text:0x813DC4FC; // type:function size:0x78
iplSDChannelSelect_813DC574 = .text:0x813DC574; // type:function size:0x80
iplSDChannelSelect_813DC5F4 = .text:0x813DC5F4; // type:function size:0x48
iplSDChannelSelect_813DC63C = .text:0x813DC63C; // type:function size:0x48
iplSDChannelSelect_813DC684 = .text:0x813DC684; // type:function size:0x90
iplSDChannelSelect_813DC714 = .text:0x813DC714; // type:function size:0x48
iplSDChannelSelect_813DC75C = .text:0x813DC75C; // type:function size:0x48
iplSDChannelSelect_813DC7A4 = .text:0x813DC7A4; // type:function size:0x48
iplSDChannelSelect_813DC7EC = .text:0x813DC7EC; // type:function size:0x14C
iplSDChannelSelect_813DC938 = .text:0x813DC938; // type:function size:0x18C
iplSDChannelSelect_813DCAC4 = .text:0x813DCAC4; // type:function size:0x42C
iplSDChannelSelect_813DCEF0 = .text:0x813DCEF0; // type:function size:0x24
enqueueStartNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB1C8; // type:function size:0x44
enqueueFinishNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB20C; // type:function size:0x48
enqueueNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB254; // type:function size:0xB4
enqueueLoadNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB308; // type:function size:0x5C
enqueuePageNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB364; // type:function size:0x5C
enqueueResultNotice__Q33ipl5scene15SDChannelSelectFUl = .text:0x813DB3C0; // type:function size:0x5C
enqueueChannelNotice__Q33ipl5scene15SDChannelSelectFUlUlUlUl = .text:0x813DB41C; // type:function size:0x5C
enqueueMoveNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB478; // type:function size:0x5C
enqueueStateNotice__Q33ipl5scene15SDChannelSelectFUlUlUlUl = .text:0x813DB4D4; // type:function size:0x5C
enqueueErrorNotice__Q33ipl5scene15SDChannelSelectFUlUl = .text:0x813DB530; // type:function size:0x5C
enqueueCommandNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB58C; // type:function size:0x60
enqueueDeleteNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB5EC; // type:function size:0x60
clearCommandQueue__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB64C; // type:function size:0x40
clearNoticeQueue__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB68C; // type:function size:0x40
processWorkerCommands__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB6CC; // type:function size:0x518
handleWorkerStartup__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBBE4; // type:function size:0xB0
handleNandTitleCount__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBC94; // type:function size:0xB8
handleNandTitleUsageComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBD4C; // type:function size:0x48
handleNandTitleUsage__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBD94; // type:function size:0xD8
compareTitleUsage__Q33ipl5scene15SDChannelSelectFPCvPCv = .text:0x813DBE6C; // type:function size:0x28
handleSDTitleList__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBE94; // type:function size:0x124
compareTitleInfo__Q33ipl5scene15SDChannelSelectFPCvPCv = .text:0x813DBFB8; // type:function size:0x28
handleSDTitleListResult__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBFE0; // type:function size:0x2AC
handleSDMountComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC28C; // type:function size:0x64
handleSDChannelUpdateComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC2F0; // type:function size:0x1B0
handleSDCardReady__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC4A0; // type:function size:0x5C
handleCardCommand__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC4FC; // type:function size:0x78
handleCopyComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC574; // type:function size:0x80
handleSDLocationUpdateComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC5F4; // type:function size:0x48
handleSDLocationReadComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC63C; // type:function size:0x48
handleMoveComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC684; // type:function size:0x90
handleBackupFitComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC714; // type:function size:0x48
handleNandSDCleanupComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC75C; // type:function size:0x48
handleSDDeleteComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC7A4; // type:function size:0x48
updateChannelNotices__Q33ipl5scene15SDChannelSelectFii = .text:0x813DC7EC; // type:function size:0x14C
processWorkerState__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC938; // type:function size:0x18C
updateDialogAnimation__Q33ipl5scene15SDChannelSelectFv = .text:0x813DCAC4; // type:function size:0x42C
setDialogMessage__Q33ipl5scene15SDChannelSelectFUlUl = .text:0x813DCEF0; // type:function size:0x24
iplSDChannelSelect_813DCF14 = .text:0x813DCF14; // type:function size:0xCC
iplSDChannelSelect_813DCFE0 = .text:0x813DCFE0; // type:function size:0xCC
iplSDChannelSelect_813DD0AC = .text:0x813DD0AC; // type:function size:0x194
@@ -4619,31 +4619,31 @@ initCalcFadeout__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE24C; // type:fun
calcFadeout__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE2EC; // type:function size:0x50
draw__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE33C; // type:function size:0x38C
destroy__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE6C8; // type:function size:0x334
iplSDChannelSelect_813DE9FC = .text:0x813DE9FC; // type:function size:0x440
iplSDChannelSelect_813DEE3C = .text:0x813DEE3C; // type:function size:0x5C
iplSDChannelSelect_813DEE98 = .text:0x813DEE98; // type:function size:0x78
iplSDChannelSelect_813DEF10 = .text:0x813DEF10; // type:function size:0x58
createBaseLayout__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE9FC; // type:function size:0x440
updateChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DEE3C; // type:function size:0x5C
updateChannelObject__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene12SDChannelObj = .text:0x813DEE98; // type:function size:0x78
calcChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DEF10; // type:function size:0x58
iplSDChannelSelect_813DEF68 = .text:0x813DEF68; // type:function size:0x27C
iplSDChannelSelect_813DF1E4 = .text:0x813DF1E4; // type:function size:0x14
iplSDChannelSelect_813DF1F8 = .text:0x813DF1F8; // type:function size:0xB0
drawChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF1F8; // type:function size:0xB0
iplSDChannelSelect_813DF2A8 = .text:0x813DF2A8; // type:function size:0x138
iplSDChannelSelect_813DF3E0 = .text:0x813DF3E0; // type:function size:0x1C
iplSDChannelSelect_813DF3FC = .text:0x813DF3FC; // type:function size:0x110
iplSDChannelSelect_813DF50C = .text:0x813DF50C; // type:function size:0x4C
iplSDChannelSelect_813DF558 = .text:0x813DF558; // type:function size:0x178
iplSDChannelSelect_813DF6D0 = .text:0x813DF6D0; // type:function size:0x164
iplSDChannelSelect_813DF834 = .text:0x813DF834; // type:function size:0x110
iplSDChannelSelect_813DF944 = .text:0x813DF944; // type:function size:0x84
iplSDChannelSelect_813DF9C8 = .text:0x813DF9C8; // type:function size:0xF8
iplSDChannelSelect_813DFAC0 = .text:0x813DFAC0; // type:function size:0xFC
iplSDChannelSelect_813DFBBC = .text:0x813DFBBC; // type:function size:0xE4
iplSDChannelSelect_813DFCA0 = .text:0x813DFCA0; // type:function size:0x50
createChannelList__Q33ipl5scene15SDChannelSelectFib = .text:0x813DF834; // type:function size:0x110
createChannelObject__Q33ipl5scene15SDChannelSelectFii = .text:0x813DF944; // type:function size:0x84
destroyUnusedChannelObjects__Q33ipl5scene15SDChannelSelectFiPQ33ipl5scene12SDChannelObj = .text:0x813DF9C8; // type:function size:0xF8
refreshChannelList__Q33ipl5scene15SDChannelSelectFv = .text:0x813DFAC0; // type:function size:0xFC
refreshAfterSDTitleList__Q33ipl5scene15SDChannelSelectFv = .text:0x813DFBBC; // type:function size:0xE4
destroyChannelObject__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene12SDChannelObj = .text:0x813DFCA0; // type:function size:0x50
iplSDChannelSelect_813DFCF0 = .text:0x813DFCF0; // type:function size:0x74
iplSDChannelSelect_813DFD64 = .text:0x813DFD64; // type:function size:0x154
iplSDChannelSelect_813DFEB8 = .text:0x813DFEB8; // type:function size:0x74
findChannelObject__Q33ipl5scene15SDChannelSelectCFii = .text:0x813DFEB8; // type:function size:0x74
iplSDChannelSelect_813DFF2C = .text:0x813DFF2C; // type:function size:0x1C0
iplSDChannelSelect_813E00EC = .text:0x813E00EC; // type:function size:0x140
iplSDChannelSelect_813E022C = .text:0x813E022C; // type:function size:0x68
hasChannelObject__Q33ipl5scene15SDChannelSelectCFii = .text:0x813E00EC; // type:function size:0x140
isChannelInCalc__Q33ipl5scene15SDChannelSelectCFiii = .text:0x813E022C; // type:function size:0x68
iplSDChannelSelect_813E0294 = .text:0x813E0294; // type:function size:0x104
iplSDChannelSelect_813E0398 = .text:0x813E0398; // type:function size:0x18
iplSDChannelSelect_813E03B0 = .text:0x813E03B0; // type:function size:0xA0
@@ -4651,13 +4651,13 @@ iplSDChannelSelect_813E0450 = .text:0x813E0450; // type:function size:0xEC
iplSDChannelSelect_813E053C = .text:0x813E053C; // type:function size:0x84
iplSDChannelSelect_813E05C0 = .text:0x813E05C0; // type:function size:0x64
iplSDChannelSelect_813E0624 = .text:0x813E0624; // type:function size:0xB4
iplSDChannelSelect_813E06D8 = .text:0x813E06D8; // type:function size:0xAC
iplSDChannelSelect_813E0784 = .text:0x813E0784; // type:function size:0x30
iplSDChannelSelect_813E07B4 = .text:0x813E07B4; // type:function size:0x30
iplSDChannelSelect_813E07E4 = .text:0x813E07E4; // type:function size:0x64
getChannelBasePane__Q33ipl5scene15SDChannelSelectCFiii = .text:0x813E06D8; // type:function size:0xAC
getCenterChannelPane__Q33ipl5scene15SDChannelSelectCFi = .text:0x813E0784; // type:function size:0x30
getChannelPane__Q33ipl5scene15SDChannelSelectCFi = .text:0x813E07B4; // type:function size:0x30
getChannelPanePosition__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene15SDChannelSelecti = .text:0x813E07E4; // type:function size:0x64
iplSDChannelSelect_813E0848 = .text:0x813E0848; // type:function size:0x3A4
iplSDChannelSelect_813E0BEC = .text:0x813E0BEC; // type:function size:0x294
iplSDChannelSelect_813E0E80 = .text:0x813E0E80; // type:function size:0x60
calcPageAnimations__Q33ipl5scene15SDChannelSelectFv = .text:0x813E0E80; // type:function size:0x60
iplSDChannelSelect_813E0EE0 = .text:0x813E0EE0; // type:function size:0x26C
iplSDChannelSelect_813E114C = .text:0x813E114C; // type:function size:0x78
iplSDChannelSelect_813E11C4 = .text:0x813E11C4; // type:function size:0x3A4
@@ -4678,10 +4678,10 @@ iplSDChannelSelect_813E2750 = .text:0x813E2750; // type:function size:0x164
iplSDChannelSelect_813E28B4 = .text:0x813E28B4; // type:function size:0x2A0
iplSDChannelSelect_813E2B54 = .text:0x813E2B54; // type:function size:0x240
startResetting__Q33ipl5scene15SDChannelSelectFv = .text:0x813E2D94; // type:function size:0x44
iplSDChannelSelect_813E2DD8 = .text:0x813E2DD8; // type:function size:0x4C
iplSDChannelSelect_813E2E24 = .text:0x813E2E24; // type:function size:0x80
iplSDChannelSelect_813E2EA4 = .text:0x813E2EA4; // type:function size:0x4C
iplSDChannelSelect_813E2EF0 = .text:0x813E2EF0; // type:function size:0x34
pop__Q33ipl5scene26SDChannelSelectNoticeQueueFv = .text:0x813E2DD8; // type:function size:0x4C
push__Q33ipl5scene27SDChannelSelectCommandQueueFRCQ33ipl5scene22SDChannelSelectCommand = .text:0x813E2E24; // type:function size:0x80
pop__Q33ipl5scene27SDChannelSelectCommandQueueFv = .text:0x813E2EA4; // type:function size:0x4C
copyFrom__Q33ipl5scene22SDChannelSelectCommandFRCQ33ipl5scene22SDChannelSelectCommand = .text:0x813E2EF0; // type:function size:0x34
@20@__dt__Q33ipl5scene15SDChannelSelectFv = .text:0x813E2F24; // type:function size:0x8
__ct__Q33ipl5scene12SDChannelObjFPQ23EGG4Heapii = .text:0x813E2F2C; // type:function size:0x130
__dt__Q33ipl5scene12SDChannelObjFv = .text:0x813E305C; // type:function size:0xA8
@@ -4837,70 +4837,70 @@ onEvent__Q33ipl5scene22SDMenuEventHandlerBaseFUlUlPv = .text:0x813EB51C; // type
onEventDerived__Q33ipl5scene22SDMenuEventHandlerBaseFUlUlPCQ33ipl10controller9Interface = .text:0x813EB5E8; // type:function size:0x4
__ct__Q33ipl5scene8SDMemoryFv = .text:0x813EB5EC; // type:function size:0x48
__dt__Q33ipl5scene8SDMemoryFv = .text:0x813EB634; // type:function size:0x5C
iplSDMemory_813EB690 = .text:0x813EB690; // type:function size:0x10A0
iplSDMemory_813EC730 = .text:0x813EC730; // type:function size:0xD4
iplSDMemory_813EC804 = .text:0x813EC804; // type:function size:0x144
iplSDMemory_813EC948 = .text:0x813EC948; // type:function size:0x20
iplSDMemory_813EC968 = .text:0x813EC968; // type:function size:0x84
iplSDMemory_813EC9EC = .text:0x813EC9EC; // type:function size:0x9C
iplSDMemory_813ECA88 = .text:0x813ECA88; // type:function size:0x74
iplSDMemory_813ECAFC = .text:0x813ECAFC; // type:function size:0x74
iplSDMemory_813ECB70 = .text:0x813ECB70; // type:function size:0x78
iplSDMemory_813ECBE8 = .text:0x813ECBE8; // type:function size:0x78
iplSDMemory_813ECC60 = .text:0x813ECC60; // type:function size:0x160
iplSDMemory_813ECDC0 = .text:0x813ECDC0; // type:function size:0x60
iplSDMemory_813ECE20 = .text:0x813ECE20; // type:function size:0x60
iplSDMemory_813ECE80 = .text:0x813ECE80; // type:function size:0x64
iplSDMemory_813ECEE4 = .text:0x813ECEE4; // type:function size:0x64
iplSDMemory_813ECF48 = .text:0x813ECF48; // type:function size:0x13C
iplSDMemory_813ED084 = .text:0x813ED084; // type:function size:0x268
iplSDMemory_813ED2EC = .text:0x813ED2EC; // type:function size:0x4CC
iplSDMemory_813ED7B8 = .text:0x813ED7B8; // type:function size:0xA4
iplSDMemory_813ED85C = .text:0x813ED85C; // type:function size:0xC4
iplSDMemory_813ED920 = .text:0x813ED920; // type:function size:0x124
iplSDMemory_813EDA44 = .text:0x813EDA44; // type:function size:0x110
iplSDMemory_813EDB54 = .text:0x813EDB54; // type:function size:0x78
iplSDMemory_813EDBCC = .text:0x813EDBCC; // type:function size:0xC0
iplSDMemory_813EDC8C = .text:0x813EDC8C; // type:function size:0x278
iplSDMemory_813EDF04 = .text:0x813EDF04; // type:function size:0xA4
iplSDMemory_813EDFA8 = .text:0x813EDFA8; // type:function size:0x130
iplSDMemory_813EE0D8 = .text:0x813EE0D8; // type:function size:0xE0
iplSDMemory_813EE1B8 = .text:0x813EE1B8; // type:function size:0x1A0
create__Q33ipl5scene8SDMemoryFPQ23EGG4HeapPQ33ipl4nand10LayoutFilePQ33ipl5scene15SDChannelSelect = .text:0x813EB690; // type:function size:0x10A0
setTitleLists__Q33ipl5scene8SDMemoryFRCQ43ipl5scene8SDMemory10TitleRangeRCQ43ipl5scene8SDMemory10TitleRange = .text:0x813EC730; // type:function size:0xD4
setScrollLimit__Q33ipl5scene8SDMemoryFv = .text:0x813EC804; // type:function size:0x144
init__Q33ipl7utility8ScrollerFv = .text:0x813EC948; // type:function size:0x20
resetScrollArrows__Q33ipl5scene8SDMemoryFv = .text:0x813EC968; // type:function size:0x84
updateScrollArrows__Q33ipl5scene8SDMemoryFUlUlUlUl = .text:0x813EC9EC; // type:function size:0x9C
showDownArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECA88; // type:function size:0x74
showUpArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECAFC; // type:function size:0x74
hideDownArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECB70; // type:function size:0x78
hideUpArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECBE8; // type:function size:0x78
updateSideArrows__Q33ipl5scene8SDMemoryFv = .text:0x813ECC60; // type:function size:0x160
showLeftArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECDC0; // type:function size:0x60
showRightArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECE20; // type:function size:0x60
hideLeftArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECE80; // type:function size:0x64
hideRightArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECEE4; // type:function size:0x64
resetDialogPaneAnimations__Q33ipl5scene8SDMemoryFv = .text:0x813ECF48; // type:function size:0x13C
calc__Q33ipl5scene8SDMemoryFv = .text:0x813ED084; // type:function size:0x268
updateState__Q33ipl5scene8SDMemoryFv = .text:0x813ED2EC; // type:function size:0x4CC
onDialogState0__Q33ipl5scene8SDMemoryFv = .text:0x813ED7B8; // type:function size:0xA4
onDialogState2__Q33ipl5scene8SDMemoryFv = .text:0x813ED85C; // type:function size:0xC4
onDialogState3__Q33ipl5scene8SDMemoryFv = .text:0x813ED920; // type:function size:0x124
onDialogState4__Q33ipl5scene8SDMemoryFv = .text:0x813EDA44; // type:function size:0x110
onDialogState6__Q33ipl5scene8SDMemoryFv = .text:0x813EDB54; // type:function size:0x78
onDialogState7__Q33ipl5scene8SDMemoryFv = .text:0x813EDBCC; // type:function size:0xC0
onDialogState8__Q33ipl5scene8SDMemoryFv = .text:0x813EDC8C; // type:function size:0x278
onDialogState9__Q33ipl5scene8SDMemoryFv = .text:0x813EDF04; // type:function size:0xA4
onDialogState10__Q33ipl5scene8SDMemoryFv = .text:0x813EDFA8; // type:function size:0x130
onDialogState11__Q33ipl5scene8SDMemoryFv = .text:0x813EE0D8; // type:function size:0xE0
onDialogState12__Q33ipl5scene8SDMemoryFv = .text:0x813EE1B8; // type:function size:0x1A0
iplSDMemory_813EE358 = .text:0x813EE358; // type:function size:0x44
iplSDMemory_813EE39C = .text:0x813EE39C; // type:function size:0xEC
iplSDMemory_813EE488 = .text:0x813EE488; // type:function size:0x1C4
iplSDMemory_813EE64C = .text:0x813EE64C; // type:function size:0x12C
iplSDMemory_813EE778 = .text:0x813EE778; // type:function size:0xA0
iplSDMemory_813EE818 = .text:0x813EE818; // type:function size:0x128
iplSDMemory_813EE940 = .text:0x813EE940; // type:function size:0xE8
iplSDMemory_813EEA28 = .text:0x813EEA28; // type:function size:0x84
iplSDMemory_813EEAAC = .text:0x813EEAAC; // type:function size:0xE8
iplSDMemory_813EEB94 = .text:0x813EEB94; // type:function size:0x148
iplSDMemory_813EECDC = .text:0x813EECDC; // type:function size:0x11C
iplSDMemory_813EEDF8 = .text:0x813EEDF8; // type:function size:0x78
iplSDMemory_813EEE70 = .text:0x813EEE70; // type:function size:0xC0
iplSDMemory_813EEF30 = .text:0x813EEF30; // type:function size:0x88
iplSDMemory_813EEFB8 = .text:0x813EEFB8; // type:function size:0x70C
iplSDMemory_813EF6C4 = .text:0x813EF6C4; // type:function size:0x14
iplSDMemory_813EF6D8 = .text:0x813EF6D8; // type:function size:0x48
onDialogState13__Q33ipl5scene8SDMemoryFv = .text:0x813EE39C; // type:function size:0xEC
onDialogState14__Q33ipl5scene8SDMemoryFv = .text:0x813EE488; // type:function size:0x1C4
onDialogState15__Q33ipl5scene8SDMemoryFv = .text:0x813EE64C; // type:function size:0x12C
onDialogState16__Q33ipl5scene8SDMemoryFv = .text:0x813EE778; // type:function size:0xA0
onDialogState17__Q33ipl5scene8SDMemoryFv = .text:0x813EE818; // type:function size:0x128
onDialogState18__Q33ipl5scene8SDMemoryFv = .text:0x813EE940; // type:function size:0xE8
onDialogState19__Q33ipl5scene8SDMemoryFv = .text:0x813EEA28; // type:function size:0x84
onDialogState20__Q33ipl5scene8SDMemoryFv = .text:0x813EEAAC; // type:function size:0xE8
onDialogState21__Q33ipl5scene8SDMemoryFv = .text:0x813EEB94; // type:function size:0x148
onDialogState22__Q33ipl5scene8SDMemoryFv = .text:0x813EECDC; // type:function size:0x11C
onDialogState23__Q33ipl5scene8SDMemoryFv = .text:0x813EEDF8; // type:function size:0x78
onDialogState24__Q33ipl5scene8SDMemoryFv = .text:0x813EEE70; // type:function size:0xC0
draw__Q33ipl5scene8SDMemoryFv = .text:0x813EEF30; // type:function size:0x88
drawTransferTitles__Q33ipl5scene8SDMemoryFv = .text:0x813EEFB8; // type:function size:0x70C
writeFourFlagBytes__Q23ipl5sceneFPUcUcUcUcUc = .text:0x813EF6C4; // type:function size:0x14
setTitleRowColors__Q23ipl5sceneFPQ34nw4r3lyt7TextBoxRCQ34nw4r2ut5ColorRCQ34nw4r2ut5Color = .text:0x813EF6D8; // type:function size:0x48
GetBeginIter__Q34nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>Fv = .text:0x813EF720; // type:function size:0x8
iplSDMemory_813EF728 = .text:0x813EF728; // type:function size:0x8
GetEndIter__Q34nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>Fv = .text:0x813EF728; // type:function size:0x8
__ne__Q24nw4r2utFQ44nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>8IteratorQ44nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>8Iterator = .text:0x813EF730; // type:function size:0x18
iplSDMemory_813EF748 = .text:0x813EF748; // type:function size:0x74
iplSDMemory_813EF7BC = .text:0x813EF7BC; // type:function size:0x128
iplSDMemory_813EF8E4 = .text:0x813EF8E4; // type:function size:0xF0
iplSDMemory_813EF9D4 = .text:0x813EF9D4; // type:function size:0x120
iplSDMemory_813EFAF4 = .text:0x813EFAF4; // type:function size:0xD8
iplSDMemory_813EFBCC = .text:0x813EFBCC; // type:function size:0xC0
iplSDMemory_813EFC8C = .text:0x813EFC8C; // type:function size:0x160
iplSDMemory_813EFDEC = .text:0x813EFDEC; // type:function size:0x128
iplSDMemory_813EFF14 = .text:0x813EFF14; // type:function size:0x24C
iplSDMemory_813F0160 = .text:0x813F0160; // type:function size:0xD8
iplSDMemory_813F0238 = .text:0x813F0238; // type:function size:0x74
iplSDMemory_813F02AC = .text:0x813F02AC; // type:function size:0x144
iplSDMemory_813F03F0 = .text:0x813F03F0; // type:function size:0x10C
iplSDMemory_813F04FC = .text:0x813F04FC; // type:function size:0x1A0
iplSDMemory_813F069C = .text:0x813F069C; // type:function size:0xD8
getControlPaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF748; // type:function size:0x74
activateControlPane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813EF7BC; // type:function size:0x128
deactivateControlPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF8E4; // type:function size:0xF0
cancelControlPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF9D4; // type:function size:0x120
onEvent__Q43ipl5scene8SDMemory23ControlPaneEventHandlerFUlUlPv = .text:0x813EFAF4; // type:function size:0xD8
getTitlePaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFBCC; // type:function size:0xC0
activateTitlePane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813EFC8C; // type:function size:0x160
deactivateTitlePane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFDEC; // type:function size:0x128
selectTitlePane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFF14; // type:function size:0x24C
onEvent__Q43ipl5scene8SDMemory21TitlePaneEventHandlerFUlUlPv = .text:0x813F0160; // type:function size:0xD8
getDialogPaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813F0238; // type:function size:0x74
activateDialogPane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813F02AC; // type:function size:0x144
deactivateDialogPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813F03F0; // type:function size:0x10C
selectDialogPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813F04FC; // type:function size:0x1A0
onEvent__Q43ipl5scene8SDMemory22DialogPaneEventHandlerFUlUlPv = .text:0x813F069C; // type:function size:0xD8
__ct__Q33ipl5scene7SettingFPQ23EGG4Heapi = .text:0x813F0774; // type:function size:0xF8
isAnimating__Q33ipl5scene7SettingFv = .text:0x813F086C; // type:function size:0x3C
getFuncMsgQ__Q33ipl5scene7SettingFv = .text:0x813F08A8; // type:function size:0x68

View File

@@ -624,8 +624,8 @@ config.libs = [
Object(Matching, "system/rvl_dec.c"),
Object(Matching, "system/RIPL_BoardRecord.c"),
Object(Matching, "system/iplSystem.cpp"),
Object(NonMatching, "system/iplController.cpp"),
Object(NonMatching, "system/iplControllerManager.cpp"),
Object(Matching, "system/iplController.cpp"),
Object(Matching, "system/iplControllerManager.cpp"),
Object(Matching, "system/iplChannelManager.cpp"),
Object(Matching, "system/iplChannelScriptManager.cpp"),
Object(Matching, "system/iplNand.cpp"),
@@ -1041,7 +1041,7 @@ config.libs = [
]
),
RevoEXLib("net", [
Object(NonMatching, "net/nettime.c"),
Object(Matching, "net/nettime.c"),
Object(Matching, "net/crc.c"),
Object(NonMatching, "net/md5.c"),
Object(NonMatching, "net/sha1.c"),
@@ -1707,7 +1707,7 @@ config.libs = [
Object(NonMatching, "fa/pf_volume.c"),
Object(NonMatching, "fa/pf_volume_apiadd.c"),
Object(NonMatching, "fa/pf_cp932.c"),
Object(NonMatching, "fa/pf_api_util.c"),
Object(Matching, "fa/pf_api_util.c"),
Object(NonMatching, "fa/pf_attach.c"),
Object(NonMatching, "fa/pf_buffering.c"),
Object(NonMatching, "fa/pf_cdelete.c"),
@@ -1774,7 +1774,7 @@ config.libs = [
Object(NonMatching, "fa/pf_unmount.c"),
Object(NonMatching, "fa/pf_unregctx.c"),
Object(NonMatching, "fa/pf_xdivide.c"),
Object(NonMatching, "fa/pf_w_api_util.c"),
Object(Matching, "fa/pf_w_api_util.c"),
Object(NonMatching, "fa/pf_w_cdelete.c"),
Object(NonMatching, "fa/pf_w_chdir.c"),
Object(NonMatching, "fa/pf_w_chdmod.c"),

View File

@@ -180,7 +180,11 @@ namespace ipl {
/*** TODO: These always generate a weak. Try and make them not do that. ***/
const nw4r::ut::Rect getTextDrawRect(const nw4r::lyt::TextBox* textBox) const { return textBox->GetTextDrawRect(mDrawInfo); }
#ifdef IPL_SDMEMORY_GET_TEXT_DRAW_RECT_OUT_OF_LINE
const nw4r::ut::Rect getTextDrawRect(const char* paneName) const;
#else
const nw4r::ut::Rect getTextDrawRect(const char* paneName) const { return getTextDrawRect(nw4r::ut::DynamicCast<nw4r::lyt::TextBox*>(mLayout.GetRootPane()->FindPaneByName(paneName))); }
#endif
const nw4r::ut::Rect getPaneRect(nw4r::lyt::Pane* pane) const { return pane->GetPaneRect(mDrawInfo); }
const nw4r::ut::Rect getPaneRect(const char* paneName) const { return getPaneRect(mLayout.GetRootPane()->FindPaneByName(paneName)); }

View File

@@ -103,7 +103,7 @@ namespace ipl {
y = r.y;
z = 0.0f;
}
#ifdef IPL_ADDRESS_EDIT_CPP
#if defined(IPL_ADDRESS_EDIT_CPP) || defined(IPL_SD_CHANNEL_SELECT_CPP)
VEC3(f32 fx, f32 fy, f32 fz);
#else
VEC3(f32 fx, f32 fy, f32 fz) {

View File

@@ -114,6 +114,8 @@ namespace ipl {
void setName(const wchar_t* value);
void setEMail(const wchar_t* value);
void setWiiNo(const wchar_t* value);
BOOL isDupCode() const;
BOOL isMyCode() const;
wchar_t mValue[0x102];
wchar_t mName[0x0c];
@@ -121,6 +123,7 @@ namespace ipl {
bool mbValidMail;
bool mbNameNotEmpty;
bool mbHasWiiNo;
AddressEdit* mpCallbackOwner;
};
enum {
@@ -144,7 +147,6 @@ namespace ipl {
TextBalloon* mpBalloon;
nand::LayoutFile* mpBalloonFile;
String mString;
AddressEdit* mpCallbackOwner;
bool mbParentalOK;
nigaoe::Object* mpNigaoe;
RFLCreateID mCreateID;

View File

@@ -85,6 +85,9 @@ namespace ipl {
}
const utility::BScroller& getBInst() { return mBScroller; }
#ifdef IPL_SDMEMORY_SCROLLER_BINST_RESET
void resetBInst() { mBScroller.reset(); }
#endif
bool isDownEnd() const { return mScroller.isDownEnd(); }
bool isUpEnd() const { return mScroller.isUpEnd(); }
@@ -98,6 +101,9 @@ namespace ipl {
void setDownLimit(f32 v) { mScroller.setDownLimit(v); }
void setUpLimit(f32 v) { mScroller.setUpLimit(v); }
#ifdef IPL_SDMEMORY_SCROLLER_STATE_ACCESSOR
void setState(int state) { mScroller.setState(state); }
#endif
bool isActive() const { return mScroller.isActive(); }

View File

@@ -0,0 +1,158 @@
#ifndef IPL_SCENE_SD_MEMORY_H
#define IPL_SCENE_SD_MEMORY_H
#include <revolution.h>
#include "layout/iplLayout.h"
#include "layout/iplGuiManager.h"
#include "scene/board/iplFocusObject.h"
#include "scene/channelEdit/iplNandSDCardManager.h"
namespace ipl {
namespace scene {
class SDChannelSelect;
class SDMemory {
public:
struct TitleRange {
s32 mByteSize;
u32 mCount;
};
SDMemory();
~SDMemory();
void create(EGG::Heap* heap, nand::LayoutFile* layoutFile, SDChannelSelect* channelSelect);
void setTitleLists(const TitleRange& nandTitles, const TitleRange& sdTitles);
bool calc();
void draw();
void setScrollLimit();
void updateSideArrows();
void resetScrollArrows();
void updateScrollArrows(u32 previousDownEnd, u32 previousUpEnd, u32 downEnd, u32 upEnd);
void showDownArrow();
void showUpArrow();
void hideDownArrow();
void hideUpArrow();
void showLeftArrow();
void showRightArrow();
void hideLeftArrow();
void hideRightArrow();
private:
s32 updateState();
void drawTransferTitles();
void onDialogState0();
void onDialogState2();
bool onDialogState3();
void onDialogState4();
void onDialogState6();
void onDialogState7();
void onDialogState8();
void onDialogState9();
void onDialogState10();
void onDialogState11();
void onDialogState12();
void onDialogState13();
void onDialogState14();
void onDialogState15();
void onDialogState16();
void onDialogState17();
void onDialogState18();
void onDialogState19();
bool onDialogState20();
void onDialogState21();
bool onDialogState22();
void onDialogState23();
bool onDialogState24();
void resetDialogPaneAnimations();
s32 getControlPaneIndex(const char* paneName);
void activateControlPane(const char* paneName, ::gui::Component* component);
void deactivateControlPane(const char* paneName);
void cancelControlPane(const char* paneName);
s32 getTitlePaneIndex(const char* paneName);
void activateTitlePane(const char* paneName, ::gui::Component* component);
void deactivateTitlePane(const char* paneName);
void selectTitlePane(const char* paneName);
s32 getDialogPaneIndex(const char* paneName);
void activateDialogPane(const char* paneName, ::gui::Component* component);
void deactivateDialogPane(const char* paneName);
void selectDialogPane(const char* paneName);
class ControlPaneEventHandler : public ::gui::EventHandler {
public:
ControlPaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
class TitlePaneEventHandler : public ::gui::EventHandler {
public:
TitlePaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
class DialogPaneEventHandler : public ::gui::EventHandler {
public:
DialogPaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
layout::Object* mpMainLayout;
layout::Object* mpTitleLayout;
layout::Object* mpDialogLayout;
layout::Object* mpProgressLayout;
gui::PaneManager* mpPaneManagers[3];
s32 mDialogState;
s32 mProcessState;
s32 mDisplayMode;
s32 mMessageId;
u32 mErrorCode;
u32 mPanelStates[3];
u32 mTitlePanelStates[5];
u32 mPanelAnimationStates[4];
SDChannelSelect* mpSDChannelSelect;
TitleRange mNandTitleRange;
TitleRange mSDTitleRange;
u32 mTitleCount;
u32 mCurrentTitle;
u32 mTitleFlags;
ESTitleId mTitleIds[96];
wchar_t mTitleNames[96][21];
u32 mTitleNameCount;
u32 mSDTitleCount;
ESTitleId mSDTitleIds[96];
u32 mNandTitleCount;
u32 mNandTitleNameCount;
ESTitleId mNandTitleIds[96];
wchar_t mCurrentTitleName[0x840];
u8 mTransferFlags[4];
u32 mTransferStatus;
u64 mTransferStartTime;
s32 mTransferFrame;
struct TitleListState {
ESTitleId* mpTitles;
u32 mCount;
ESTitleId* mpSecondaryTitles;
u32 mSecondaryCount;
ESTitleId* mpNames;
u32 mNameCount;
} mTitleListState;
scroller mScroller;
s32 mButtonState;
u8 mControllerFlags[4];
u32 mFinalState[3];
u8 mFinalFlags[4];
};
} // namespace scene
} // namespace ipl
#endif

View File

@@ -1,18 +1,302 @@
#ifndef IPL_SCENE_SD_CHANNEL_SELECT_H
#define IPL_SCENE_SD_CHANNEL_SELECT_H
#include "iplSceneHeader.h"
#include "iplSceneUIHeader.h"
#include "math/iplInterporation.h"
#include "scene/sdButton/iplSDButton.h"
#include "system/iplChannelRsoThread.h"
#include "system/iplNandSDWorker.h"
namespace ipl {
namespace scene {
FADER_SCENE_CLASS(SDChannelSelect) {
class SDChannelObj {
public:
SDChannelSelect(EGG::Heap * heap);
SDChannelObj(EGG::Heap* heap, int page, int index);
~SDChannelObj();
EGG::Heap* getHeap() const { return mpHeap; }
int getPage() const { return mPage; }
int getIndex() const { return mIndex; }
private:
u8 unk_0x58[0x728];
};
} // namespace scene
} // namespace ipl
friend class SDChannelSelect;
#endif // IPL_SCENE_SD_CHANNEL_SELECT_H
nw4r::ut::Link mListLink;
EGG::ExpHeap* mpDialogHeap;
EGG::ExpHeap* mpChannelHeap;
EGG::Heap* mpHeap;
u32 mState;
int mPage;
int mIndex;
nand::LayoutFile* mpLayoutFile;
nw4r::lyt::Pane* mpPane;
layout::Animator* mpPaneAnimator;
layout::Object* mpBaseLayout;
layout::Animator* mpBaseAnimator;
layout::Object* mpPageLayout;
layout::Animator* mpPageAnimators[3];
int mPageAnimation;
int mPageAnimationFrame;
layout::Object* mpDialogLayout;
layout::Animator* mpDialogAnimator;
int mDialogState;
int mDialogFrame;
int mDialogTimer;
int mAnimationState;
nw4r::lyt::Group* mpNewMessageGroup;
int mNewMessageCount;
u8 mbNewMessageGroupActive;
int mNewMessageState;
int mNewMessageFrame;
f32 mOffsetX;
f32 mOffsetY;
f32 mAspectRatioScale;
int mStateFlags;
void* mpThumbnailData;
NandSDWorker::SDAppMetaEntry mAppMeta;
};
extern "C" void iplSDChannelObj_813E3104(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E311C(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
EGG::ExpHeap* secondHeap);
extern "C" void iplSDChannelObj_813E322C(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E3178(SDChannelObj* channel, nw4r::lyt::Pane* pane);
extern "C" void iplSDChannelObj_813E3180(SDChannelObj* channel, nand::LayoutFile* layoutFile);
extern "C" void iplSDChannelObj_813E3304(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E330C(SDChannelObj* channel);
extern "C" void* iplSDChannelObj_813E3128(SDChannelObj* channel);
extern "C" bool iplSDChannelObj_813E3330(SDChannelObj* channel);
union SDChannelSelectCommandArguments {
u32 values[3];
NandSDWorker::AppBlocksInfo* appBlocks[3];
NandSDWorker::TitleIdList* titleLists[3];
void* pointers[3];
};
struct SDChannelSelectCommand {
u32 type;
u64 titleId;
SDChannelSelectCommandArguments arguments;
void copyFrom(const SDChannelSelectCommand& other);
};
struct SDChannelSelectCommandQueue {
SDChannelSelectCommand commands[4];
int capacity;
int count;
int readIndex;
int writeIndex;
SDChannelSelectCommandQueue(u32 capacity, u32 count, u32 readIndex, u32 writeIndex)
: capacity(capacity), count(count), readIndex(readIndex), writeIndex(writeIndex) {
}
bool push(const SDChannelSelectCommand& command);
bool pop();
};
struct SDChannelSelectTitleInfo {
ESTitleId32 titleId;
bool used;
};
struct SDChannelSelectNoticeQueue {
SDChannelSelectCommand notices[42];
int capacity;
int count;
int readIndex;
int writeIndex;
SDChannelSelectNoticeQueue(u32 capacity, u32 count, u32 readIndex, u32 writeIndex)
: capacity(capacity), count(count), readIndex(readIndex), writeIndex(writeIndex) {
}
bool pop();
};
FADER_SCENE_CLASS(SDChannelSelect) {
public:
enum {
PAGE_COUNT = 5,
};
SDChannelSelect(EGG::Heap* heap);
virtual ~SDChannelSelect();
NandSDWorker::WorkSDState getSDState() const {
return static_cast<NandSDWorker::WorkSDState>(mCurrentSDState);
}
NandSDWorker* getWorker() const { return mpSDWorker; }
virtual BOOL isResetProcessDone();
virtual void startResetting();
virtual void prepare();
virtual void create();
virtual void draw();
virtual void destroy();
virtual void initCalcFadeout();
virtual void calcCommon();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
virtual FaderSceneCommand calcFadeout();
static const char* mscChannelPaneNames[PAGE_COUNT][MAX_CHANNEL_INDEX];
static const char* mscBasePaneNames[PAGE_COUNT];
static const char* mscPicturePaneNames[PAGE_COUNT];
static const char* mscEdgePaneNames[PAGE_COUNT];
static const char* mscClockPaneNames[3];
static const char* mscMaskPaneName;
private:
void enqueueStartNotice();
bool enqueueFinishNotice();
bool enqueueNotice(u32 highTitleId, u32 lowTitleId, u32 result);
bool enqueueLoadNotice();
bool enqueuePageNotice();
bool enqueueResultNotice(u32 result);
bool enqueueChannelNotice(u32 controller, u32 page, u32 index, u32 value);
bool enqueueMoveNotice(u32 controller, u32 page, u32 index);
bool enqueueStateNotice(u32 controller, u32 page, u32 index, u32 state);
bool enqueueErrorNotice(u32 page, u32 index);
bool enqueueCommandNotice(u32 page, u32 index, u32 command);
bool enqueueDeleteNotice(u32 controller, u32 page, u32 index);
void clearCommandQueue();
void clearNoticeQueue();
void calcChannelObjects();
void updateChannelObjects();
void updateChannelObject(SDChannelObj* channel);
void drawChannelObjects();
bool isChannelInCalc(int page, int index, int currentPage) const;
nw4r::lyt::Pane* getChannelBasePane(int page, int index, int currentPage) const;
nw4r::lyt::Pane* getCenterChannelPane(int index) const;
nw4r::lyt::Pane* getChannelPane(int index) const;
static math::VEC3 getChannelPanePosition(SDChannelSelect* scene, int index);
void calcPageAnimations();
void updateArrowVisibility();
void processWorkerState();
void updateDialogAnimation();
void processWorkerCommands();
void handleWorkerStartup();
void handleNandTitleCount();
void handleNandTitleUsage();
void handleNandTitleUsageComplete();
void handleSDTitleList();
void handleSDTitleListResult();
void refreshAfterSDTitleList();
void handleSDChannelUpdateComplete();
void updateChannelNotices(int pageOffset, int index);
void handleSDMountComplete();
void handleCopyComplete();
void handleDeleteComplete();
void handleMoveComplete();
void handleStorageCheckComplete();
void handleCardCommand();
void handleSDCardReady();
void handleSDLocationUpdateComplete();
void handleSDLocationReadComplete();
void handleBackupFitComplete();
void handleNandSDCleanupComplete();
void handleSDDeleteComplete();
bool setDialogMessage(u32 state, u32 message);
static int compareTitleUsage(const void* lhs, const void* rhs);
static int compareTitleInfo(const void* lhs, const void* rhs);
void createChannelList(int page, bool force);
void destroyChannelObject(SDChannelObj* channel);
void destroyUnusedChannelObjects(int currentPage, SDChannelObj* keepChannel);
void refreshChannelList();
bool hasChannelObject(int page, int index) const;
SDChannelObj* findChannelObject(int page, int index) const;
void createChannelObject(int page, int index);
void createBaseLayout();
void updateNoCardLayouts();
void createChannelThumbnails();
nw4r::ut::List mChannelObjects;
nand::LayoutFile* mpLayoutFile;
layout::Object* mpLayout;
math::HermiteIntp<math::VEC3>* mpPageAnimations[4];
gui::PaneManager* mpPaneManager;
layout::Object* mpNoCardLayout;
layout::Object* mpPageLayouts[3];
layout::Object* mpDialogLayout;
SDButtonEventHandlerBase* mpButtonEventHandler;
int mState;
int mCurrentPage;
int mPageCount;
int mCurrentChannelIndex;
f32 mThumbOffsetX;
f32 mThumbOffsetY;
nw4r::math::VEC3 mPosition;
math::VEC2 mScale;
f32 mAspectRatioScale;
bool mbLeftArrowVisible;
bool mbRightArrowVisible;
u8 mArrowState;
u8 mNoCardState;
EGG::UnitHeap* mpLayoutHeap;
EGG::ExpHeap* mpDialogHeap;
EGG::ExpHeap* mpChannelHeap;
EGG::ExpHeap* mpThumbnailHeap;
nw4r::math::VEC2 mPointerPosition;
int mControllerChannel;
int mSourcePage;
int mSourceIndex;
int mDestinationPage;
int mDestinationIndex;
int mPendingPage;
int mPendingIndex;
int mMoveState;
bool mbButtonEnabled;
bool mbDialogActive;
u16 mInputFlags;
SDChannelObj* mpCurrentChannel;
layout::Object* mpStateLayout;
layout::Object* mpHelpLayout;
EGG::ExpHeap* mpRsoHeap;
channel::RsoThread* mpRsoThread;
u32 mCommandQueueState;
SDChannelSelectCommandQueue mCommandQueue;
SDChannelSelectNoticeQueue mNoticeQueue;
int mCurrentSDState;
int mPreviousSDState;
int mWorkerState;
int mWorkerCommand;
EGG::Heap* mpWorkerHeap;
EGG::Heap* mpThumbnailWorkHeap;
NandSDWorker* mpSDWorker;
ESTitleId32* mpSDTitleIds;
SDChannelSelectTitleInfo* mpSDTitleInfo;
NandSDWorker::TitleUsage* mpNandTitleInfo;
u32 mFirstTitleCount;
u32 mSecondTitleCount;
SDChannelObj* mpCurrentLoadedChannel;
u32 mSDTitleCount;
u32 mNandTitleCount;
u32* mpChannelTitleIds;
u32 mPendingOperation;
int mLastOperation;
layout::Object* mpErrorLayout;
layout::Object* mpPointerLayout;
layout::Object* mpHelpButtonLayout;
int mOperationResult;
u8 mbShowNoCardMessage;
u8 mbOperationActive;
u8 mbSDCardBroken;
u32 mOperationState;
u32 mDialogState;
nand::File* mpSaveDataFile;
u32 mAnimationState;
u32 mAnimationTarget;
OSTime mOperationStartTime;
nand::File* mpCorruptIconFile;
u8 mbHazardTitleFound;
u8 mbChannelLimitReached;
u8 mbInitialLoadComplete;
u8 mbNeedsRefresh;
};
}
}
#endif

View File

@@ -17,7 +17,11 @@ namespace ipl {
virtual ~APScanThread(); // 0x08
virtual void* Run(); // 0x0C
virtual void unk_0x2C() = 0; // 0x2C
#ifdef IPL_SETTING_IMPLEMENTATION
virtual void unk_0x2C();
#else
virtual void unk_0x2C() = 0;
#endif
void setResultData(unsigned short* buffer);
void setParam();

View File

@@ -3,14 +3,171 @@
#include "iplSceneHeader.h"
#ifdef IPL_SETTING_IMPLEMENTATION
#include <revolution/os.h>
#include "layout/iplGuiManager.h"
#include "layout/GUIManager.h"
#include "iplwww/www_wiisetting.h"
#include "iplwww/www_browser.h"
#include "system/iplKeyboard.h"
#include "system/iplNand.h"
#include "utility/iplThread.h"
extern "C" {
#include <revolution/wd.h>
}
#endif
namespace ipl {
namespace controller {
class Interface;
}
}
namespace ipl {
namespace scene {
#ifdef IPL_SETTING_IMPLEMENTATION
class Setting;
class APScanThread;
class APEvent : public ::gui::EventHandler {
public:
APEvent(Setting* setting) : ::gui::EventHandler(), mpSetting(setting) {}
virtual void onEvent(u32 componentID, u32 event, void* data);
private:
Setting* mpSetting;
};
struct SettingAnimation {
u8 unknown[0x14];
int state;
};
struct SettingAPScanList {
u8 unknown[0x14];
u16 count;
u8 entries[0x7fe];
union {
WDBssDesc_* currentDescriptor;
u16* currentDescriptorWords;
};
};
#endif
FADER_SCENE_CLASS(Setting) {
public:
Setting(EGG::Heap * heap, int arg);
void setInitializeResult(bool, int);
#ifdef IPL_SETTING_IMPLEMENTATION
virtual ~Setting();
bool isAnimating();
void getFuncMsgQ();
void resetFuncMsgQ();
void createBrowser();
void initDirectUrl();
void initString();
void initWiiSettingData();
void initNickName();
void initSecurityKey();
void initSSID();
void initIP();
void initDNS();
void initProxy();
void initBasic();
void initMTU();
void initSecA();
void initVersion();
void updateController_();
void setSE();
void changeVideoMode();
bool isInitialSequenceExit(const ::ipl::controller::Interface* input);
bool updateScreenMode();
void initHTMLText();
void initMessage();
void initKeyboard(const char* text);
bool checkInputString(const wchar_t* text);
int checkIPString(const wchar_t* text);
void setDefaultBackString();
void calcKeyboard();
void calcSetting();
void onTextInputOK();
void setDisPos();
void setNickName();
void setSecurityKey();
void setSSID();
void setIP();
void setDNS();
void setProxy();
void setBasic();
void setMTU();
void setParePass();
void setPareRePass();
void setPareJudgePass();
void setSecA();
void setReSecA();
void setMasterKey();
void adjustSecA(wchar_t* text);
void reAdjustSecA();
u8 checkTextNum(const char* text);
bool checkSpace();
void convertIP(char* destination, const u8* address);
void convertRevIP(u8* destination, const char* address);
void initScroll();
void updateScroll();
void setAPDraw();
int getRadioLevel(const WDBssDesc_* descriptor);
void setUseEULA_Init_();
void setUseEULA_Cancel_();
void setUseEULA_Start_();
void setUseEULA_WaitStopMotor_();
bool validateEULA_();
void setUpdate_Init_();
void setUpdate_WaitAcceptDialog_();
void setUpdate_ConnectTestStart_();
void setUpdate_ConnectTestCreateWait_();
void setUpdate_ConnectTestRun_();
void setUpdate_ConnectTestFailed_();
void setUpdate_SuccessDialog_();
void setUpdate_NoUpdateDialog_();
void setUpdate_EULAInit_();
void setUpdate_Reboot_();
void makeErrorMessage();
bool calcSafeMode();
void waitStart();
void waitFinish();
bool isWaitPlaying();
void initAP();
void resetAP();
void redrawAP();
void scanAP();
void setNUP();
void setUSBAP();
void cancelUSBAP();
void AOSSProcess();
void RakuProcess();
void setUpdate_();
void setUseEULA_();
void start_point_event(const char* pageName);
void start_trig_event(const char* pageName);
void start_left_event(const char* pageName);
int get_arw_no(const char* paneName);
int get_ap_no(const char* buttonName);
void makeSupportCode();
int getErrorNum();
virtual void destroy();
virtual void prepare();
virtual void create();
virtual void calc();
virtual void draw();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
virtual FaderSceneCommand calcFadeout();
virtual BOOL isResetAcceptable() const;
#endif
u16 getProfileID();
void setInitializeResult(bool, int);
void setConnectTestResult(int, int, bool, int);
int getUpdateTiming();
@@ -25,7 +182,85 @@ namespace ipl {
};
private:
#ifdef IPL_SETTING_IMPLEMENTATION
int mUpdateTiming;
u8 unk_0x5C;
u8 unk_0x5D[3];
nand::Base* mpWWWLibraryFile;
nand::Base* mpSettingHTMLFile;
nand::Base* mpWWWArchiveFile;
nand::Base* mpFontFile;
nand::Base* mpBackgroundTPLFile;
int unk_0x74;
int unk_0x78;
int unk_0x7C;
int mProfileIDMode;
int unk_0x84;
int mAOSSState;
int mRakuState;
int mFuncMsgPending;
int unk_0x94;
ESTitleId mUpdateTitleId;
u32 mPrepareTick;
u8 mSettingData[0x16];
u8 unk_0xBA[2];
nand::LayoutFile* mpSettingLayoutFile;
layout::Object* mpChangeLayout;
layout::Object* mpMainLayout;
layout::Object* mpWaitLayout;
SettingAnimation* mpFirstAnimation;
SettingAnimation* mpSecondAnimation;
APEvent* mpEventHandler;
gui::PaneManager* mpPaneManager;
void* mpUSBAPThread;
utility::ut_thread* mpAOSSThread;
utility::ut_thread* mpRakuRakuThread;
APScanThread* mpAPScanThread;
SettingAPScanList mAPScanList;
void* mpMem1BrowserBuffer;
u32 unk_0x908;
void* mpMem2BrowserBuffer;
void* mpBrowserStringBuffer;
int unk_0x914;
int unk_0x918;
u8 unk_0x91C[4];
ext_ead::www::ImeData* mpBrowserData;
www::wiisetting::WiiData* mpWiiSettingData;
www::wiisetting::WiiFlag* mpWiiSettingFlag;
u8 unk_0x92C;
u8 unk_0x92D[3];
int unk_0x930;
www::wiisetting::SetStringBuf* mpStringBuffer;
#ifdef IPL_SETTING_IMPLEMENTATION
wchar_t unk_0x938[0x101];
#else
u8 unk_0x938[0x202];
#endif
u8 unk_0xB3A;
u8 mBrowserCreated;
keyboard::Manager::State mKeyboardState;
int mInitialArgument;
int mAspectRatio;
int mProgressiveMode;
int mEuRgb60Mode;
u8 mIsResetAcceptable;
u8 unk_0xB5D[3];
OSMessageQueue mFuncMessageQueue;
OSMessage mFuncMessages[5];
int unk_0xB94;
int mState;
int unk_0xB9C;
OSTime mCreatePageTime;
u32 unk_0xBA8;
u8 unk_0xBAC;
u8 unk_0xBAD[3];
u8 unk_0xBB0[0x10];
static void* mem1Buffer_;
static void* mem2Buffer_;
#else
u8 unk_0x58[0xB68];
#endif
};
} // namespace scene
} // namespace ipl

View File

@@ -63,10 +63,14 @@ namespace ipl {
// clang-format on
#ifdef IPL_CONTROLLER_NATIVE_HIERARCHY
#ifdef IPL_CONTROLLER_OUT_OF_LINE_INTERFACE
#define IPL_CONTROLLER_DEFAULT_VIRTUAL(signature, implementation) virtual signature;
#else
#ifdef IPL_CONTROLLER_INLINE_INTERFACE
#define IPL_CONTROLLER_DEFAULT_VIRTUAL(signature, implementation) virtual signature implementation
#else
#define IPL_CONTROLLER_DEFAULT_VIRTUAL(signature, implementation) virtual signature;
#endif
#endif
class Interface {
public:
@@ -79,7 +83,7 @@ namespace ipl {
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinch() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinchTrg() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinchOffTrg() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int decide() const, { return 0; })
virtual int decide() const = 0;
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool repeat(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(BOOL rumble(int type = 0), { return FALSE; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(void cancelRumbling(), { })

View File

@@ -118,6 +118,11 @@ namespace ipl {
int getLastResult() { return mLastResult; }
/** @return If the dialog is moving onto the next state. */
bool doingNextState() { return mbNextState; }
#ifdef IPL_SDMEMORY_DIALOG_STATE_ACCESSOR
int getStateForSDMemory() const { return mState; }
int getResultForSDMemory() const { return mResult; }
void setTitleForSDMemory(const wchar_t* text) { set_title(text); }
#endif
/*=================*/
/* DIALOG BUTTON 0 */
@@ -322,6 +327,9 @@ namespace ipl {
void setProgBarLength(int len) { mProgBarLen = len; }
/** @return The current length of the progress bar */
int getProgBarLength() { return mProgBarLen; }
#ifdef IPL_SDMEMORY_DIALOG_PROGRESS_FRAME_ACCESSOR
int getProgBarFrame() const { return mProgBarFrame; }
#endif
/**
* Dialog component handler (Automatically executed by the GUI manager)

View File

@@ -63,8 +63,15 @@ namespace ipl {
textinput::MemoManager::StateType type; // 0x00
KeyboardState iplType; // 0x04
bool pressOK; // 0x08
#ifdef IPL_SETTING_IMPLEMENTATION
u8 reservedByte;
#else
u8 unused_0x09;
#endif
wchar_t* wcString; // 0x0C
#ifdef IPL_SETTING_IMPLEMENTATION
State& operator=(const State& other);
#endif
} State;
Manager() : mpManager(NULL), mEvent(), mCurrentConChan(0), mbActivated(false), mpSaveFile(NULL) {}

View File

@@ -179,6 +179,10 @@ namespace ipl {
static const int SD_APP_BACKUP_THUMBNAIL_LENGTH = 0xC800;
#ifdef IPL_SDMEMORY_COMPLETION_PCT_ACCESSOR
static int getCompletionPct() { return s_completion_pct; }
#endif
protected:
static const int FAT_PAGES = 8;
static const int DATA_PAGES = 32;

View File

@@ -50,6 +50,12 @@ namespace ipl {
int getPrevPage() { return mLastPrevPage; }
#ifdef IPL_SD_CHANNEL_SELECT_ACCESS
int getLastSDPrevPage() { return mLastSDPrevPage; }
void setLastSDPrevPage(int page) { mLastSDPrevPage = page; }
BOOL didntGotoSDMenu() const { return mData.didntGotoSDMenu; }
#endif
bool hasPhotoMP3Dummy() { return mbPhotoMP3; }
bool hasPhoto2Title() { return mbPhoto2; }
bool hasPhoto2DummyCheck() { return mbPhoto2Check; }

View File

@@ -49,6 +49,9 @@ namespace ipl {
public:
Scroller();
#ifdef IPL_SDMEMORY_SCROLLER_INIT_OUT_OF_LINE
void init();
#else
void init() {
mState = 0;
mScroll = 0.0f;
@@ -56,6 +59,7 @@ namespace ipl {
mUpLimit = 0.0f;
mDownLimit = 0.0f;
}
#endif
void calc();
f32 get() const;
@@ -69,6 +73,9 @@ namespace ipl {
void setDownLimit(f32 v) { mDownLimit = v; }
void setUpLimit(f32 v) { mUpLimit = v; }
#ifdef IPL_SDMEMORY_SCROLLER_STATE_ACCESSOR
void setState(int state) { mState = state; }
#endif
void addScroll(f32 v) { mScroll += v; }

View File

@@ -88,7 +88,11 @@ namespace nw4r {
PaneList& GetChildList() { return mChildList; }
const math::VEC3& GetTranslate() { return mTranslate; }
#ifdef IPL_SDMEMORY_SET_TRANSLATE_OUT_OF_LINE
void SetTranslate(const math::VEC3& translate);
#else
void SetTranslate(const math::VEC3& translate) { mTranslate = translate; }
#endif
void SetTranslate(const math::VEC2& translate) { SetTranslate(math::VEC3(translate.x, translate.y, 0.0f)); }
const math::VEC3& GetRotate() const { return mRotate; }

View File

@@ -55,6 +55,12 @@ namespace nw4r {
NW4R_ASSERT(type < TEXTCOLOR_MAX);
return mTextColors[type];
}
#ifdef IPL_SDMEMORY_SET_TEXT_COLORS
void SetTextColors(const ut::Color& first, const ut::Color& second) {
mTextColors[0] = first;
mTextColors[1] = second;
}
#endif
void SetTextColor(u32 type, ut::Color value) {
NW4R_ASSERT(type < TEXTCOLOR_MAX);
mTextColors[type] = value;

View File

@@ -0,0 +1,127 @@
#include <revolution/fa/types.h>
#include <revolution/types.h>
static s32 pf_error_to_api_error[] = {FA_ERR_SUCCESS, FA_ERR_EINVAL, FA_ERR_EINVAL, FA_ERR_ENOENT, FA_ERR_EBUSY, FA_ERR_ENOTEMPTY, FA_ERR_ENOSPC,
FA_ERR_ENOEXEC, FA_ERR_EEXIST, FA_ERR_ENOEXEC, FA_ERR_EINVAL, FA_ERR_EWRTPROTECT, FA_ERR_ENOSYS, FA_ERR_ENOEXEC,
FA_ERR_ENOEXEC, FA_ERR_ENOEXEC, FA_ERR_EACCES, FA_ERR_EIO, FA_ERR_ENOEXEC, FA_ERR_EACCES, FA_ERR_ENOENT,
FA_ERR_ENFILE, FA_ERR_EMFILE, FA_ERR_EISDIR, FA_ERR_EACCES, FA_ERR_EPERM, FA_ERR_ENOEXEC, FA_ERR_ENOEXEC,
FA_ERR_ENOEXEC, FA_ERR_ENOEXEC, FA_ERR_ENOMEM, FA_ERR_EINVAL, FA_ERR_EINVAL, FA_ERR_ENOEXEC, FA_ERR_ENOENT,
FA_ERR_ENOEXEC, FA_ERR_ENOEXEC, FA_ERR_EFBIG, FA_ERR_EBADF, FA_ERR_ENOLCK};
s32 PFAPI_ParseOpenModeString(const char* mode_str) {
s32 open_mode = 0;
u32 i = 0;
if (mode_str == NULL) {
open_mode = 10;
return open_mode;
}
switch (mode_str[i++]) {
case 'r': {
open_mode = 2;
break;
}
case 'w': {
open_mode = 1;
break;
}
case 'a': {
open_mode = 4;
break;
}
default: {
return 0;
}
}
if (mode_str[i] == 'b') {
i++;
}
switch (mode_str[i++]) {
case 0: {
return open_mode;
}
case 't':
default: {
return 0;
}
case '+': {
switch (mode_str[i]) {
case 0: {
return open_mode | 8;
}
default: {
return 0;
}
}
}
}
return 0;
}
s32 PFAPI_convertError(s32 err) {
if (err == 0) {
return 0;
}
if (err == -1) {
return -1;
}
if (err > 0 && err < 0xA0) {
return pf_error_to_api_error[err];
}
if (err == 0x1000) {
err = FA_ERR_EIO;
}
return err;
}
s32 PFAPI_convertDriverError(s32 err) {
if (err == 0) {
return 0;
}
if (err <= 0) {
return err;
}
if ((u32)err < 0xA0) {
err = 1;
}
return err;
}
s32 PFAPI_convertReturnValue(s32 err) {
if (err == 0) {
return 0;
}
return -1;
}
s32 PFAPI_convertReturnValue4feof(s32 err) {
if (err == 1) {
return 1;
}
if (err == 0) {
return 0;
}
return -1;
}
void* PFAPI_convertReturnValue2NULL(s32 err, void* p_stream) {
void* ret;
if (err) {
ret = NULL;
} else {
ret = p_stream;
}
return ret;
}
s32 PFAPI_convertReturnValue4unmount(s32 err) {
if (err == 0) {
return 0;
}
if (err == 1) {
return 1;
}
return -1;
}

1726
libs/RVL_SDK/src/fa/pf_dir.c Normal file

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,53 @@
#include <revolution/types.h>
s32 PFWAPI_ParseOpenModeString(const unsigned short* mode_str) {
s32 open_mode = 0;
u32 i = 0;
if (mode_str == NULL) {
open_mode = 10;
return open_mode;
}
switch (mode_str[i++]) {
case 'r': {
open_mode = 2;
break;
}
case 'w': {
open_mode = 1;
break;
}
case 'a': {
open_mode = 4;
break;
}
default: {
return 0;
}
}
if (mode_str[i] == 'b') {
i++;
}
switch (mode_str[i++]) {
case 0: {
return open_mode;
}
case 't':
default: {
return 0;
}
case '+': {
switch (mode_str[i]) {
case 0: {
return open_mode | 8;
}
default: {
return 0;
}
}
}
}
return 0;
}

1824
libs/RVL_SDK/src/kpad/KPAD.c Normal file

File diff suppressed because it is too large Load Diff

3519
libs/RVL_SDK/src/wad/wad.c Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,33 @@
#include <revolution/net.h>
#include <private/nwc24.h>
#include <private/os.h>
#include <revolution/NWC24.h>
#include <revolution/OS.h>
NWC24Err NWC24iEpochSecondsToDate(NWC24Date* date, OSTime time);
NWC24Err NWC24iDateToOSCalendarTime(OSCalendarTime* cal, const NWC24Date* date);
BOOL NETGetUniversalCalendar(OSCalendarTime* pTime) {
static s64 whenCached = 0;
NWC24Date date;
s64 universalTime;
if (whenCached == 0 ||
whenCached + OSSecondsToTicks(60) < __OSGetSystemTime()) {
NWC24iSynchronizeRtcCounter(FALSE);
whenCached = __OSGetSystemTime();
}
if (NWC24iGetUniversalTime(&universalTime) >= 0 &&
NWC24iEpochSecondsToDate(&date, universalTime) >= 0 &&
NWC24iDateToOSCalendarTime(pTime, &date) >= 0) {
return TRUE;
}
OSTicksToCalendarTime(OSGetTime(), pTime);
return FALSE;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -18,7 +18,9 @@
#define IPL_CONTROLLER_NATIVE_HIERARCHY
#define IPL_CONTROLLER_INLINE_INTERFACE
#define IPL_CONTROLLER_OUT_OF_LINE_INTERFACE
#include "system/iplController.h"
#undef IPL_CONTROLLER_OUT_OF_LINE_INTERFACE
#undef IPL_CONTROLLER_INLINE_INTERFACE
#undef IPL_CONTROLLER_NATIVE_HIERARCHY
#include "system/iplSystem.h"
@@ -91,6 +93,21 @@ namespace ipl {
}
}
}
bool ipl::controller::Interface::isValidBtn() const {
return false;
}
bool ipl::controller::Interface::downTrg(u32 button) const {
return false;
}
int ipl::controller::Interface::pinch() const {
return 0;
}
bool ipl::controller::Interface::down(u32 button) const {
return false;
}
KPADStatus* ipl::controller::Interface::getKPADStatus() const {
return NULL;
}
int ipl::controller::Base::decide() const {
return unk_0x08 == 5;
}
@@ -325,9 +342,15 @@ namespace ipl {
bool ipl::controller::Master::upTrg(u32 button) const {
return call(button, kUpTrgMember);
}
bool ipl::controller::Interface::upTrg(u32 button) const {
return false;
}
bool ipl::controller::Master::repeat(u32 button) const {
return call(button, kRepeatMember);
}
bool ipl::controller::Interface::repeat(u32 button) const {
return false;
}
int ipl::controller::Master::decide() const {
bool current = false;
bool ret = false;
@@ -365,6 +388,71 @@ void ipl::controller::Master::setForceInvalid(bool flag) {
}
return ret;
}
void ipl::controller::Interface::read() {}
int ipl::controller::Interface::getSubStickY() const {
return 0;
}
int ipl::controller::Interface::getSubStickX() const {
return 0;
}
int ipl::controller::Interface::getMainStickY() const {
return 0;
}
int ipl::controller::Interface::getMainStickX() const {
return 0;
}
bool ipl::controller::Interface::isValidDpd() const {
return false;
}
PADStatus* ipl::controller::Interface::getPADStatus() const {
return NULL;
}
f32 ipl::controller::Interface::getDpdDistance() const {
return 0.0f;
}
ipl::math::VEC2 ipl::controller::Interface::getHorizon() const {
return ipl::math::VEC2(0.0f, 0.0f);
}
ipl::math::VEC2 ipl::controller::Interface::getDpdProjectionPos() const {
return ipl::math::VEC2(0.0f, 0.0f);
}
ipl::math::VEC2 ipl::controller::Interface::getDpdPos() const {
return ipl::math::VEC2(0.0f, 0.0f);
}
int ipl::controller::Interface::getClassicReleaseFlag() const {
return 0;
}
int ipl::controller::Interface::getClassicTrigFlag() const {
return 0;
}
int ipl::controller::Interface::getClassicHoldFlag() const {
return 0;
}
int ipl::controller::Interface::getReleaseFlag() const {
return 0;
}
int ipl::controller::Interface::getTrigFlag() const {
return 0;
}
int ipl::controller::Interface::getHoldFlag() const {
return 0;
}
void ipl::controller::Interface::cancelRumbling() {}
BOOL ipl::controller::Interface::rumble(int type) {
return FALSE;
}
int ipl::controller::Interface::pinchOffTrg() const {
return 0;
}
int ipl::controller::Interface::pinchTrg() const {
return 0;
}
int ipl::controller::Interface::getChannel() const {
return -1;
}
int ipl::controller::Interface::getType() const {
return -1;
}
void ipl::controller::Base::setForceInvalid(bool flag) {
unk_0x1C = flag;
}

View File

@@ -98,11 +98,7 @@ namespace ipl {
probe_valid:
{
s32 read = KPADRead(chan, &mKPADStatus[chan], 1);
if (read > 0) {
if (mKPADStatus[chan].wpad_err == -4 || deviceType == 0xfd) {
goto store_null;
}
if (read > 0 && mKPADStatus[chan].wpad_err != -4 && deviceType != 0xfd) {
mInvalidCount[chan] = 0;
if (mKPADStatus[chan].wpad_err == -7 || deviceType == 0 || deviceType == 0xfb ||
deviceType == 0xfc || deviceType == 0xff) {
@@ -120,7 +116,10 @@ namespace ipl {
} else {
mControllers[chan] = NULL;
}
} else if (read == 0) {
} else {
if (read != 0) {
goto store_null;
}
mInvalidCount[chan]++;
if (mInvalidCount[chan] > 0x3c) {
mInvalidCount[chan] = 0x3c;
@@ -129,8 +128,6 @@ namespace ipl {
}
mControllers[chan] = NULL;
}
} else {
goto store_null;
}
}
goto channel_done;