From 06c07f4a671fab222242d1b8460acd7dd9ca1157 Mon Sep 17 00:00:00 2001 From: myst6re Date: Sat, 24 Feb 2024 22:04:43 +0100 Subject: [PATCH] WIP --- src/ff8/battle/trace.cpp | 1410 ++++++++++++++++++++------------------ src/ff8/battle/trace.h | 26 + src/ff8/vram.cpp | 165 ++--- src/ff8_opengl.cpp | 456 +----------- 4 files changed, 826 insertions(+), 1231 deletions(-) diff --git a/src/ff8/battle/trace.cpp b/src/ff8/battle/trace.cpp index b6bc299b..9859780c 100644 --- a/src/ff8/battle/trace.cpp +++ b/src/ff8/battle/trace.cpp @@ -1,3 +1,26 @@ +/****************************************************************************/ +// Copyright (C) 2009 Aali132 // +// Copyright (C) 2018 quantumpencil // +// Copyright (C) 2018 Maxime Bacoux // +// Copyright (C) 2020 Chris Rizzitello // +// Copyright (C) 2020 John Pritchard // +// Copyright (C) 2024 myst6re // +// Copyright (C) 2024 Julian Xhokaxhiu // +// Copyright (C) 2023 Cosmos // +// Copyright (C) 2023 Tang-Tang Zhou // +// // +// This file is part of FFNx // +// // +// FFNx is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License // +// // +// FFNx is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +/****************************************************************************/ + #include "trace.h" #include "../../log.h" #include "../../patch.h" @@ -36,6 +59,15 @@ int bdlinktask3(uint32_t *a1, int cb) return ((int(*)(uint32_t*, int))0x507DA0)(a1, cb); } +void battle_read_effect_alloc() +{ + int battle_read_effect_magic_id_dword_1D99740 = *(int *)0x1D99740; + + ffnx_trace("%s: effect_id=%d\n", __func__, battle_read_effect_magic_id_dword_1D99740); + + ((void(*)())0x571BF0)(); +} + void *battle_set_texture_action_upload1_sub_5057A0_call1(DWORD *pos_and_size, char *texture_data) { int *dword1D980F8 = (int *)0x1D980F8; @@ -87,711 +119,721 @@ void *battle_set_texture_action_upload1_sub_5057A0_call5(DWORD *pos_and_size, ch } -void(*taurus_funcs[327])() = {}; +void(*effect_funcs[327])() = {}; -#define taurusFunc(NUM) \ - void taurus##NUM() \ +#define effectFunc(NUM) \ + void effect##NUM() \ { \ int texture_data_related_dword_27970C4 = *(int *)0x27970C4; \ ffnx_info("%s: texture_data=0x%X\n", __func__, *(char **)(texture_data_related_dword_27970C4 + 180)); \ - taurus_funcs[NUM](); \ + effect_funcs[NUM](); \ } -#define taurusReplace(NUM) \ - if (int(taurus_funcs[NUM]) > 0xAF0000) {\ - taurus_funcs2[NUM] = taurus##NUM; \ +#define effectReplace(NUM) \ + if (int(effect_funcs[NUM]) > 0xAF0000) {\ + effect_funcs2[NUM] = effect##NUM; \ } -taurusFunc(0) -taurusFunc(1) -taurusFunc(2) -taurusFunc(3) -taurusFunc(4) -taurusFunc(5) -taurusFunc(6) -taurusFunc(7) -taurusFunc(8) -taurusFunc(9) -taurusFunc(10) -taurusFunc(11) -taurusFunc(12) -taurusFunc(13) -taurusFunc(14) -taurusFunc(15) -taurusFunc(16) -taurusFunc(17) -taurusFunc(18) -taurusFunc(19) -taurusFunc(20) -taurusFunc(21) -taurusFunc(22) -taurusFunc(23) -taurusFunc(24) -taurusFunc(25) -taurusFunc(26) -taurusFunc(27) -taurusFunc(28) -taurusFunc(29) -taurusFunc(30) -taurusFunc(31) -taurusFunc(32) -taurusFunc(33) -taurusFunc(34) -taurusFunc(35) -taurusFunc(36) -taurusFunc(37) -taurusFunc(38) -taurusFunc(39) -taurusFunc(40) -taurusFunc(41) -taurusFunc(42) -taurusFunc(43) -taurusFunc(44) -taurusFunc(45) -taurusFunc(46) -taurusFunc(47) -taurusFunc(48) -taurusFunc(49) -taurusFunc(50) -taurusFunc(51) -taurusFunc(52) -taurusFunc(53) -taurusFunc(54) -taurusFunc(55) -taurusFunc(56) -taurusFunc(57) -taurusFunc(58) -taurusFunc(59) -taurusFunc(60) -taurusFunc(61) -taurusFunc(62) -taurusFunc(63) -taurusFunc(64) -taurusFunc(65) -taurusFunc(66) -taurusFunc(67) -taurusFunc(68) -taurusFunc(69) -taurusFunc(70) -taurusFunc(71) -taurusFunc(72) -taurusFunc(73) -taurusFunc(74) -taurusFunc(75) -taurusFunc(76) -taurusFunc(77) -taurusFunc(78) -taurusFunc(79) -taurusFunc(80) -taurusFunc(81) -taurusFunc(82) -taurusFunc(83) -taurusFunc(84) -taurusFunc(85) -taurusFunc(86) -taurusFunc(87) -taurusFunc(88) -taurusFunc(89) -taurusFunc(90) -taurusFunc(91) -taurusFunc(92) -taurusFunc(93) -taurusFunc(94) -taurusFunc(95) -taurusFunc(96) -taurusFunc(97) -taurusFunc(98) -taurusFunc(99) -taurusFunc(100) -taurusFunc(101) -taurusFunc(102) -taurusFunc(103) -taurusFunc(104) -taurusFunc(105) -taurusFunc(106) -taurusFunc(107) -taurusFunc(108) -taurusFunc(109) -taurusFunc(110) -taurusFunc(111) -taurusFunc(112) -taurusFunc(113) -taurusFunc(114) -taurusFunc(115) -taurusFunc(116) -taurusFunc(117) -taurusFunc(118) -taurusFunc(119) -taurusFunc(120) -taurusFunc(121) -taurusFunc(122) -taurusFunc(123) -taurusFunc(124) -taurusFunc(125) -taurusFunc(126) -taurusFunc(127) -taurusFunc(128) -taurusFunc(129) -taurusFunc(130) -taurusFunc(131) -taurusFunc(132) -taurusFunc(133) -taurusFunc(134) -taurusFunc(135) -taurusFunc(136) -taurusFunc(137) -taurusFunc(138) -taurusFunc(139) -taurusFunc(140) -taurusFunc(141) -taurusFunc(142) -taurusFunc(143) -taurusFunc(144) -taurusFunc(145) -taurusFunc(146) -taurusFunc(147) -taurusFunc(148) -taurusFunc(149) -taurusFunc(150) -taurusFunc(151) -taurusFunc(152) -taurusFunc(153) -taurusFunc(154) -taurusFunc(155) -taurusFunc(156) -taurusFunc(157) -taurusFunc(158) -taurusFunc(159) -taurusFunc(160) -taurusFunc(161) -taurusFunc(162) -taurusFunc(163) -taurusFunc(164) -taurusFunc(165) -taurusFunc(166) -taurusFunc(167) -taurusFunc(168) -taurusFunc(169) -taurusFunc(170) -taurusFunc(171) -taurusFunc(172) -taurusFunc(173) -taurusFunc(174) -taurusFunc(175) -taurusFunc(176) -taurusFunc(177) -taurusFunc(178) -taurusFunc(179) -taurusFunc(180) -taurusFunc(181) -taurusFunc(182) -taurusFunc(183) -taurusFunc(184) -taurusFunc(185) -taurusFunc(186) -taurusFunc(187) -taurusFunc(188) -taurusFunc(189) -taurusFunc(190) -taurusFunc(191) -taurusFunc(192) -taurusFunc(193) -taurusFunc(194) -taurusFunc(195) -taurusFunc(196) -taurusFunc(197) -taurusFunc(198) -taurusFunc(199) -taurusFunc(200) -taurusFunc(201) -taurusFunc(202) -taurusFunc(203) -taurusFunc(204) -taurusFunc(205) -taurusFunc(206) -taurusFunc(207) -taurusFunc(208) -taurusFunc(209) -taurusFunc(210) -taurusFunc(211) -taurusFunc(212) -taurusFunc(213) -taurusFunc(214) -taurusFunc(215) -taurusFunc(216) -taurusFunc(217) -taurusFunc(218) -taurusFunc(219) -taurusFunc(220) -taurusFunc(221) -taurusFunc(222) -taurusFunc(223) -taurusFunc(224) -taurusFunc(225) -taurusFunc(226) -taurusFunc(227) -taurusFunc(228) -taurusFunc(229) -taurusFunc(230) -taurusFunc(231) -taurusFunc(232) -taurusFunc(233) -taurusFunc(234) -taurusFunc(235) -taurusFunc(236) -taurusFunc(237) -taurusFunc(238) -taurusFunc(239) -taurusFunc(240) -taurusFunc(241) -taurusFunc(242) -taurusFunc(243) -taurusFunc(244) -taurusFunc(245) -taurusFunc(246) -taurusFunc(247) -taurusFunc(248) -taurusFunc(249) -taurusFunc(250) -taurusFunc(251) -taurusFunc(252) -taurusFunc(253) -taurusFunc(254) -taurusFunc(255) -taurusFunc(256) -taurusFunc(257) -taurusFunc(258) -taurusFunc(259) -taurusFunc(260) -taurusFunc(261) -taurusFunc(262) -taurusFunc(263) -taurusFunc(264) -taurusFunc(265) -taurusFunc(266) -taurusFunc(267) -taurusFunc(268) -taurusFunc(269) -taurusFunc(270) -taurusFunc(271) -taurusFunc(272) -taurusFunc(273) -taurusFunc(274) -taurusFunc(275) -taurusFunc(276) -taurusFunc(277) -taurusFunc(278) -taurusFunc(279) -taurusFunc(280) -taurusFunc(281) -taurusFunc(282) -taurusFunc(283) -taurusFunc(284) -taurusFunc(285) -taurusFunc(286) -taurusFunc(287) -taurusFunc(288) -taurusFunc(289) -taurusFunc(290) -taurusFunc(291) -taurusFunc(292) -taurusFunc(293) -taurusFunc(294) -taurusFunc(295) -taurusFunc(296) -taurusFunc(297) -taurusFunc(298) -taurusFunc(299) -taurusFunc(300) -taurusFunc(301) -taurusFunc(302) -taurusFunc(303) -taurusFunc(304) -taurusFunc(305) -taurusFunc(306) -taurusFunc(307) -taurusFunc(308) -taurusFunc(309) -taurusFunc(310) -taurusFunc(311) -taurusFunc(312) -taurusFunc(313) -taurusFunc(314) -taurusFunc(315) -taurusFunc(316) -taurusFunc(317) -taurusFunc(318) -taurusFunc(319) -taurusFunc(320) -taurusFunc(321) -taurusFunc(322) -taurusFunc(323) -taurusFunc(324) -taurusFunc(325) -taurusFunc(326) -taurusFunc(327) - - - -void battle_execute_loop_sub_AFFA20() +effectFunc(0) +effectFunc(1) +effectFunc(2) +effectFunc(3) +effectFunc(4) +effectFunc(5) +effectFunc(6) +effectFunc(7) +effectFunc(8) +effectFunc(9) +effectFunc(10) +effectFunc(11) +effectFunc(12) +effectFunc(13) +effectFunc(14) +effectFunc(15) +effectFunc(16) +effectFunc(17) +effectFunc(18) +effectFunc(19) +effectFunc(20) +effectFunc(21) +effectFunc(22) +effectFunc(23) +effectFunc(24) +effectFunc(25) +effectFunc(26) +effectFunc(27) +effectFunc(28) +effectFunc(29) +effectFunc(30) +effectFunc(31) +effectFunc(32) +effectFunc(33) +effectFunc(34) +effectFunc(35) +effectFunc(36) +effectFunc(37) +effectFunc(38) +effectFunc(39) +effectFunc(40) +effectFunc(41) +effectFunc(42) +effectFunc(43) +effectFunc(44) +effectFunc(45) +effectFunc(46) +effectFunc(47) +effectFunc(48) +effectFunc(49) +effectFunc(50) +effectFunc(51) +effectFunc(52) +effectFunc(53) +effectFunc(54) +effectFunc(55) +effectFunc(56) +effectFunc(57) +effectFunc(58) +effectFunc(59) +effectFunc(60) +effectFunc(61) +effectFunc(62) +effectFunc(63) +effectFunc(64) +effectFunc(65) +effectFunc(66) +effectFunc(67) +effectFunc(68) +effectFunc(69) +effectFunc(70) +effectFunc(71) +effectFunc(72) +effectFunc(73) +effectFunc(74) +effectFunc(75) +effectFunc(76) +effectFunc(77) +effectFunc(78) +effectFunc(79) +effectFunc(80) +effectFunc(81) +effectFunc(82) +effectFunc(83) +effectFunc(84) +effectFunc(85) +effectFunc(86) +effectFunc(87) +effectFunc(88) +effectFunc(89) +effectFunc(90) +effectFunc(91) +effectFunc(92) +effectFunc(93) +effectFunc(94) +effectFunc(95) +effectFunc(96) +effectFunc(97) +effectFunc(98) +effectFunc(99) +effectFunc(100) +effectFunc(101) +effectFunc(102) +effectFunc(103) +effectFunc(104) +effectFunc(105) +effectFunc(106) +effectFunc(107) +effectFunc(108) +effectFunc(109) +effectFunc(110) +effectFunc(111) +effectFunc(112) +effectFunc(113) +effectFunc(114) +effectFunc(115) +effectFunc(116) +effectFunc(117) +effectFunc(118) +effectFunc(119) +effectFunc(120) +effectFunc(121) +effectFunc(122) +effectFunc(123) +effectFunc(124) +effectFunc(125) +effectFunc(126) +effectFunc(127) +effectFunc(128) +effectFunc(129) +effectFunc(130) +effectFunc(131) +effectFunc(132) +effectFunc(133) +effectFunc(134) +effectFunc(135) +effectFunc(136) +effectFunc(137) +effectFunc(138) +effectFunc(139) +effectFunc(140) +effectFunc(141) +effectFunc(142) +effectFunc(143) +effectFunc(144) +effectFunc(145) +effectFunc(146) +effectFunc(147) +effectFunc(148) +effectFunc(149) +effectFunc(150) +effectFunc(151) +effectFunc(152) +effectFunc(153) +effectFunc(154) +effectFunc(155) +effectFunc(156) +effectFunc(157) +effectFunc(158) +effectFunc(159) +effectFunc(160) +effectFunc(161) +effectFunc(162) +effectFunc(163) +effectFunc(164) +effectFunc(165) +effectFunc(166) +effectFunc(167) +effectFunc(168) +effectFunc(169) +effectFunc(170) +effectFunc(171) +effectFunc(172) +effectFunc(173) +effectFunc(174) +effectFunc(175) +effectFunc(176) +effectFunc(177) +effectFunc(178) +effectFunc(179) +effectFunc(180) +effectFunc(181) +effectFunc(182) +effectFunc(183) +effectFunc(184) +effectFunc(185) +effectFunc(186) +effectFunc(187) +effectFunc(188) +effectFunc(189) +effectFunc(190) +effectFunc(191) +effectFunc(192) +effectFunc(193) +effectFunc(194) +effectFunc(195) +effectFunc(196) +effectFunc(197) +effectFunc(198) +effectFunc(199) +effectFunc(200) +effectFunc(201) +effectFunc(202) +effectFunc(203) +effectFunc(204) +effectFunc(205) +effectFunc(206) +effectFunc(207) +effectFunc(208) +effectFunc(209) +effectFunc(210) +effectFunc(211) +effectFunc(212) +effectFunc(213) +effectFunc(214) +effectFunc(215) +effectFunc(216) +effectFunc(217) +effectFunc(218) +effectFunc(219) +effectFunc(220) +effectFunc(221) +effectFunc(222) +effectFunc(223) +effectFunc(224) +effectFunc(225) +effectFunc(226) +effectFunc(227) +effectFunc(228) +effectFunc(229) +effectFunc(230) +effectFunc(231) +effectFunc(232) +effectFunc(233) +effectFunc(234) +effectFunc(235) +effectFunc(236) +effectFunc(237) +effectFunc(238) +effectFunc(239) +effectFunc(240) +effectFunc(241) +effectFunc(242) +effectFunc(243) +effectFunc(244) +effectFunc(245) +effectFunc(246) +effectFunc(247) +effectFunc(248) +effectFunc(249) +effectFunc(250) +effectFunc(251) +effectFunc(252) +effectFunc(253) +effectFunc(254) +effectFunc(255) +effectFunc(256) +effectFunc(257) +effectFunc(258) +effectFunc(259) +effectFunc(260) +effectFunc(261) +effectFunc(262) +effectFunc(263) +effectFunc(264) +effectFunc(265) +effectFunc(266) +effectFunc(267) +effectFunc(268) +effectFunc(269) +effectFunc(270) +effectFunc(271) +effectFunc(272) +effectFunc(273) +effectFunc(274) +effectFunc(275) +effectFunc(276) +effectFunc(277) +effectFunc(278) +effectFunc(279) +effectFunc(280) +effectFunc(281) +effectFunc(282) +effectFunc(283) +effectFunc(284) +effectFunc(285) +effectFunc(286) +effectFunc(287) +effectFunc(288) +effectFunc(289) +effectFunc(290) +effectFunc(291) +effectFunc(292) +effectFunc(293) +effectFunc(294) +effectFunc(295) +effectFunc(296) +effectFunc(297) +effectFunc(298) +effectFunc(299) +effectFunc(300) +effectFunc(301) +effectFunc(302) +effectFunc(303) +effectFunc(304) +effectFunc(305) +effectFunc(306) +effectFunc(307) +effectFunc(308) +effectFunc(309) +effectFunc(310) +effectFunc(311) +effectFunc(312) +effectFunc(313) +effectFunc(314) +effectFunc(315) +effectFunc(316) +effectFunc(317) +effectFunc(318) +effectFunc(319) +effectFunc(320) +effectFunc(321) +effectFunc(322) +effectFunc(323) +effectFunc(324) +effectFunc(325) +effectFunc(326) +effectFunc(327) + +struct struc_46_menu_callbacks { + uint32_t controller_callback; + uint32_t field_4; + uint32_t renderer_callback; + uint32_t other_renderer_callback; + uint8_t field_10; + uint8_t field_11; + uint8_t field_12; + uint8_t field_13; +}; + +void battle_set_controller_render_sub_4B9440(int id, int controller_callback, int renderer_callback, int other_renderer_callback) { - int texture_data_related_dword_27970C4 = *(int *)0x27970C4; - ffnx_info("%s: texture_data=0x%X\n", __func__, *(char **)(texture_data_related_dword_27970C4 + 180)); - ((void(*)())0xAFFA20)(); -} + ffnx_trace("%s: id=%d (%X, %X, %X)\n", __func__, id, controller_callback, renderer_callback, other_renderer_callback); -void battle_execute_loop_sub_AFFE40() -{ - int texture_data_related_dword_27970C4 = *(int *)0x27970C4; - ffnx_info("%s: texture_data=0x%X\n", __func__, *(char **)(texture_data_related_dword_27970C4 + 180)); - ((void(*)())0xAFFE40)(); + struc_46_menu_callbacks *battle_menu_callbacks_array_unk_1D76300 = (struc_46_menu_callbacks *)0x1D76300; + + struc_46_menu_callbacks *v4 = &battle_menu_callbacks_array_unk_1D76300[id]; + v4->field_10 = -1; + v4->field_11 = -1; + v4->field_12 = 0; + v4->controller_callback = controller_callback; + v4->renderer_callback = renderer_callback; + v4->other_renderer_callback = other_renderer_callback; } void battle_trace_init() { replace_function(0x507D10, bdlinktask2); replace_call(0x506260 + 0x20, bdlinktask3); - replace_call(0xAFDC20 + 0x3B, battle_set_texture_action_upload1_sub_5057A0_call1); + replace_call(0x50A8D0 + 0x63, battle_read_effect_alloc); + replace_function(0x4B9440, battle_set_controller_render_sub_4B9440); + /* replace_call(0xAFDC20 + 0x3B, battle_set_texture_action_upload1_sub_5057A0_call1); replace_call(0xAFDC20 + 0x85, battle_set_texture_action_upload1_sub_5057A0_call2); replace_call(0xAFDC20 + 0xB6, battle_set_texture_action_upload1_sub_5057A0_call3); replace_call(0xAFE110 + 0x22, battle_set_texture_action_upload1_sub_5057A0_call4); - replace_call(0xAFE160 + 0x2F, battle_set_texture_action_upload1_sub_5057A0_call5); - replace_call(0xAF4F10 + 0x1B5, battle_execute_loop_sub_AFFA20); - replace_call(0xAF4F10 + 0x1BF, battle_execute_loop_sub_AFFE40); + replace_call(0xAFE160 + 0x2F, battle_set_texture_action_upload1_sub_5057A0_call5); */ //void *func_pointer = (void*)0x1871EFC; // taurus //void *func_pointer = (void*)0x18735D8; // cerberus void *func_pointer = (void *)0x1877914; // leviathan - memcpy(taurus_funcs, func_pointer, 327 * sizeof(uint32_t)); - - void(**taurus_funcs2)() = (void(**)())func_pointer; - - taurusReplace(0) - taurusReplace(1) - taurusReplace(2) - taurusReplace(3) - taurusReplace(4) - taurusReplace(5) - taurusReplace(6) - taurusReplace(7) - taurusReplace(8) - taurusReplace(9) - taurusReplace(10) - taurusReplace(11) - taurusReplace(12) - taurusReplace(13) - taurusReplace(14) - taurusReplace(15) - taurusReplace(16) - taurusReplace(17) - taurusReplace(18) - taurusReplace(19) - taurusReplace(20) - taurusReplace(21) - taurusReplace(22) - taurusReplace(23) - taurusReplace(24) - taurusReplace(25) - taurusReplace(26) - taurusReplace(27) - taurusReplace(28) - taurusReplace(29) - taurusReplace(30) - taurusReplace(31) - taurusReplace(32) - taurusReplace(33) - taurusReplace(34) - taurusReplace(35) - taurusReplace(36) - taurusReplace(37) - taurusReplace(38) - taurusReplace(39) - taurusReplace(40) - taurusReplace(41) - taurusReplace(42) - taurusReplace(43) - taurusReplace(44) - taurusReplace(45) - taurusReplace(46) - taurusReplace(47) - taurusReplace(48) - taurusReplace(49) - taurusReplace(50) - taurusReplace(51) - taurusReplace(52) - taurusReplace(53) - taurusReplace(54) - taurusReplace(55) - taurusReplace(56) - taurusReplace(57) - taurusReplace(58) - taurusReplace(59) - taurusReplace(60) - taurusReplace(61) - taurusReplace(62) - taurusReplace(63) - taurusReplace(64) - taurusReplace(65) - taurusReplace(66) - taurusReplace(67) - taurusReplace(68) - taurusReplace(69) - taurusReplace(70) - taurusReplace(71) - taurusReplace(72) - taurusReplace(73) - taurusReplace(74) - taurusReplace(75) - taurusReplace(76) - taurusReplace(77) - taurusReplace(78) - taurusReplace(79) - taurusReplace(80) - taurusReplace(81) - taurusReplace(82) - taurusReplace(83) - taurusReplace(84) - taurusReplace(85) - taurusReplace(86) - taurusReplace(87) - taurusReplace(88) - taurusReplace(89) - taurusReplace(90) - taurusReplace(91) - taurusReplace(92) - taurusReplace(93) - taurusReplace(94) - taurusReplace(95) - taurusReplace(96) - taurusReplace(97) - taurusReplace(98) - taurusReplace(99) - taurusReplace(100) - taurusReplace(101) - taurusReplace(102) - taurusReplace(103) - taurusReplace(104) - taurusReplace(105) - taurusReplace(106) - taurusReplace(107) - taurusReplace(108) - taurusReplace(109) - taurusReplace(110) - taurusReplace(111) - taurusReplace(112) - taurusReplace(113) - taurusReplace(114) - taurusReplace(115) - taurusReplace(116) - taurusReplace(117) - taurusReplace(118) - taurusReplace(119) - taurusReplace(120) - taurusReplace(121) - taurusReplace(122) - taurusReplace(123) - taurusReplace(124) - taurusReplace(125) - taurusReplace(126) - taurusReplace(127) - taurusReplace(128) - taurusReplace(129) - taurusReplace(130) - taurusReplace(131) - taurusReplace(132) - taurusReplace(133) - taurusReplace(134) - taurusReplace(135) - taurusReplace(136) - taurusReplace(137) - taurusReplace(138) - taurusReplace(139) - taurusReplace(140) - taurusReplace(141) - taurusReplace(142) - taurusReplace(143) - taurusReplace(144) - taurusReplace(145) - taurusReplace(146) - taurusReplace(147) - taurusReplace(148) - taurusReplace(149) - taurusReplace(150) - taurusReplace(151) - taurusReplace(152) - taurusReplace(153) - taurusReplace(154) - taurusReplace(155) - taurusReplace(156) - taurusReplace(157) - taurusReplace(158) - taurusReplace(159) - taurusReplace(160) - taurusReplace(161) - taurusReplace(162) - taurusReplace(163) - taurusReplace(164) - taurusReplace(165) - taurusReplace(166) - taurusReplace(167) - taurusReplace(168) - taurusReplace(169) - taurusReplace(170) - taurusReplace(171) - taurusReplace(172) - taurusReplace(173) - taurusReplace(174) - taurusReplace(175) - taurusReplace(176) - taurusReplace(177) - taurusReplace(178) - taurusReplace(179) - taurusReplace(180) - taurusReplace(181) - taurusReplace(182) - taurusReplace(183) - taurusReplace(184) - taurusReplace(185) - taurusReplace(186) - taurusReplace(187) - taurusReplace(188) - taurusReplace(189) - taurusReplace(190) - taurusReplace(191) - taurusReplace(192) - taurusReplace(193) - taurusReplace(194) - taurusReplace(195) - taurusReplace(196) - taurusReplace(197) - taurusReplace(198) - taurusReplace(199) - taurusReplace(200) - taurusReplace(201) - taurusReplace(202) - taurusReplace(203) - taurusReplace(204) - taurusReplace(205) - taurusReplace(206) - taurusReplace(207) - taurusReplace(208) - taurusReplace(209) - taurusReplace(210) - taurusReplace(211) - taurusReplace(212) - taurusReplace(213) - taurusReplace(214) - taurusReplace(215) - taurusReplace(216) - taurusReplace(217) - taurusReplace(218) - taurusReplace(219) - taurusReplace(220) - taurusReplace(221) - taurusReplace(222) - taurusReplace(223) - taurusReplace(224) - taurusReplace(225) - taurusReplace(226) - taurusReplace(227) - taurusReplace(228) - taurusReplace(229) - taurusReplace(230) - taurusReplace(231) - taurusReplace(232) - taurusReplace(233) - taurusReplace(234) - taurusReplace(235) - taurusReplace(236) - taurusReplace(237) - taurusReplace(238) - taurusReplace(239) - taurusReplace(240) - taurusReplace(241) - taurusReplace(242) - taurusReplace(243) - taurusReplace(244) - taurusReplace(245) - taurusReplace(246) - taurusReplace(247) - taurusReplace(248) - taurusReplace(249) - taurusReplace(250) - taurusReplace(251) - taurusReplace(252) - taurusReplace(253) - taurusReplace(254) - taurusReplace(255) - taurusReplace(256) - taurusReplace(257) - taurusReplace(258) - taurusReplace(259) - taurusReplace(260) - taurusReplace(261) - taurusReplace(262) - taurusReplace(263) - taurusReplace(264) - taurusReplace(265) - taurusReplace(266) - taurusReplace(267) - taurusReplace(268) - taurusReplace(269) - taurusReplace(270) - taurusReplace(271) - taurusReplace(272) - taurusReplace(273) - taurusReplace(274) - taurusReplace(275) - taurusReplace(276) - taurusReplace(277) - taurusReplace(278) - taurusReplace(279) - taurusReplace(280) - taurusReplace(281) - taurusReplace(282) - taurusReplace(283) - taurusReplace(284) - taurusReplace(285) - taurusReplace(286) - taurusReplace(287) - taurusReplace(288) - taurusReplace(289) - taurusReplace(290) - taurusReplace(291) - taurusReplace(292) - taurusReplace(293) - taurusReplace(294) - taurusReplace(295) - taurusReplace(296) - taurusReplace(297) - taurusReplace(298) - taurusReplace(299) - taurusReplace(300) - taurusReplace(301) - taurusReplace(302) - taurusReplace(303) - taurusReplace(304) - taurusReplace(305) - taurusReplace(306) - taurusReplace(307) - taurusReplace(308) - taurusReplace(309) - taurusReplace(310) - taurusReplace(311) - taurusReplace(312) - taurusReplace(313) - taurusReplace(314) - taurusReplace(315) - taurusReplace(316) - taurusReplace(317) - taurusReplace(318) - taurusReplace(319) - taurusReplace(320) - taurusReplace(321) - taurusReplace(322) - taurusReplace(323) - taurusReplace(324) - taurusReplace(325) - taurusReplace(326) - taurusReplace(327) + memcpy(effect_funcs, func_pointer, 327 * sizeof(uint32_t)); + + void(**effect_funcs2)() = (void(**)())func_pointer; + + effectReplace(0) + effectReplace(1) + effectReplace(2) + effectReplace(3) + effectReplace(4) + effectReplace(5) + effectReplace(6) + effectReplace(7) + effectReplace(8) + effectReplace(9) + effectReplace(10) + effectReplace(11) + effectReplace(12) + effectReplace(13) + effectReplace(14) + effectReplace(15) + effectReplace(16) + effectReplace(17) + effectReplace(18) + effectReplace(19) + effectReplace(20) + effectReplace(21) + effectReplace(22) + effectReplace(23) + effectReplace(24) + effectReplace(25) + effectReplace(26) + effectReplace(27) + effectReplace(28) + effectReplace(29) + effectReplace(30) + effectReplace(31) + effectReplace(32) + effectReplace(33) + effectReplace(34) + effectReplace(35) + effectReplace(36) + effectReplace(37) + effectReplace(38) + effectReplace(39) + effectReplace(40) + effectReplace(41) + effectReplace(42) + effectReplace(43) + effectReplace(44) + effectReplace(45) + effectReplace(46) + effectReplace(47) + effectReplace(48) + effectReplace(49) + effectReplace(50) + effectReplace(51) + effectReplace(52) + effectReplace(53) + effectReplace(54) + effectReplace(55) + effectReplace(56) + effectReplace(57) + effectReplace(58) + effectReplace(59) + effectReplace(60) + effectReplace(61) + effectReplace(62) + effectReplace(63) + effectReplace(64) + effectReplace(65) + effectReplace(66) + effectReplace(67) + effectReplace(68) + effectReplace(69) + effectReplace(70) + effectReplace(71) + effectReplace(72) + effectReplace(73) + effectReplace(74) + effectReplace(75) + effectReplace(76) + effectReplace(77) + effectReplace(78) + effectReplace(79) + effectReplace(80) + effectReplace(81) + effectReplace(82) + effectReplace(83) + effectReplace(84) + effectReplace(85) + effectReplace(86) + effectReplace(87) + effectReplace(88) + effectReplace(89) + effectReplace(90) + effectReplace(91) + effectReplace(92) + effectReplace(93) + effectReplace(94) + effectReplace(95) + effectReplace(96) + effectReplace(97) + effectReplace(98) + effectReplace(99) + effectReplace(100) + effectReplace(101) + effectReplace(102) + effectReplace(103) + effectReplace(104) + effectReplace(105) + effectReplace(106) + effectReplace(107) + effectReplace(108) + effectReplace(109) + effectReplace(110) + effectReplace(111) + effectReplace(112) + effectReplace(113) + effectReplace(114) + effectReplace(115) + effectReplace(116) + effectReplace(117) + effectReplace(118) + effectReplace(119) + effectReplace(120) + effectReplace(121) + effectReplace(122) + effectReplace(123) + effectReplace(124) + effectReplace(125) + effectReplace(126) + effectReplace(127) + effectReplace(128) + effectReplace(129) + effectReplace(130) + effectReplace(131) + effectReplace(132) + effectReplace(133) + effectReplace(134) + effectReplace(135) + effectReplace(136) + effectReplace(137) + effectReplace(138) + effectReplace(139) + effectReplace(140) + effectReplace(141) + effectReplace(142) + effectReplace(143) + effectReplace(144) + effectReplace(145) + effectReplace(146) + effectReplace(147) + effectReplace(148) + effectReplace(149) + effectReplace(150) + effectReplace(151) + effectReplace(152) + effectReplace(153) + effectReplace(154) + effectReplace(155) + effectReplace(156) + effectReplace(157) + effectReplace(158) + effectReplace(159) + effectReplace(160) + effectReplace(161) + effectReplace(162) + effectReplace(163) + effectReplace(164) + effectReplace(165) + effectReplace(166) + effectReplace(167) + effectReplace(168) + effectReplace(169) + effectReplace(170) + effectReplace(171) + effectReplace(172) + effectReplace(173) + effectReplace(174) + effectReplace(175) + effectReplace(176) + effectReplace(177) + effectReplace(178) + effectReplace(179) + effectReplace(180) + effectReplace(181) + effectReplace(182) + effectReplace(183) + effectReplace(184) + effectReplace(185) + effectReplace(186) + effectReplace(187) + effectReplace(188) + effectReplace(189) + effectReplace(190) + effectReplace(191) + effectReplace(192) + effectReplace(193) + effectReplace(194) + effectReplace(195) + effectReplace(196) + effectReplace(197) + effectReplace(198) + effectReplace(199) + effectReplace(200) + effectReplace(201) + effectReplace(202) + effectReplace(203) + effectReplace(204) + effectReplace(205) + effectReplace(206) + effectReplace(207) + effectReplace(208) + effectReplace(209) + effectReplace(210) + effectReplace(211) + effectReplace(212) + effectReplace(213) + effectReplace(214) + effectReplace(215) + effectReplace(216) + effectReplace(217) + effectReplace(218) + effectReplace(219) + effectReplace(220) + effectReplace(221) + effectReplace(222) + effectReplace(223) + effectReplace(224) + effectReplace(225) + effectReplace(226) + effectReplace(227) + effectReplace(228) + effectReplace(229) + effectReplace(230) + effectReplace(231) + effectReplace(232) + effectReplace(233) + effectReplace(234) + effectReplace(235) + effectReplace(236) + effectReplace(237) + effectReplace(238) + effectReplace(239) + effectReplace(240) + effectReplace(241) + effectReplace(242) + effectReplace(243) + effectReplace(244) + effectReplace(245) + effectReplace(246) + effectReplace(247) + effectReplace(248) + effectReplace(249) + effectReplace(250) + effectReplace(251) + effectReplace(252) + effectReplace(253) + effectReplace(254) + effectReplace(255) + effectReplace(256) + effectReplace(257) + effectReplace(258) + effectReplace(259) + effectReplace(260) + effectReplace(261) + effectReplace(262) + effectReplace(263) + effectReplace(264) + effectReplace(265) + effectReplace(266) + effectReplace(267) + effectReplace(268) + effectReplace(269) + effectReplace(270) + effectReplace(271) + effectReplace(272) + effectReplace(273) + effectReplace(274) + effectReplace(275) + effectReplace(276) + effectReplace(277) + effectReplace(278) + effectReplace(279) + effectReplace(280) + effectReplace(281) + effectReplace(282) + effectReplace(283) + effectReplace(284) + effectReplace(285) + effectReplace(286) + effectReplace(287) + effectReplace(288) + effectReplace(289) + effectReplace(290) + effectReplace(291) + effectReplace(292) + effectReplace(293) + effectReplace(294) + effectReplace(295) + effectReplace(296) + effectReplace(297) + effectReplace(298) + effectReplace(299) + effectReplace(300) + effectReplace(301) + effectReplace(302) + effectReplace(303) + effectReplace(304) + effectReplace(305) + effectReplace(306) + effectReplace(307) + effectReplace(308) + effectReplace(309) + effectReplace(310) + effectReplace(311) + effectReplace(312) + effectReplace(313) + effectReplace(314) + effectReplace(315) + effectReplace(316) + effectReplace(317) + effectReplace(318) + effectReplace(319) + effectReplace(320) + effectReplace(321) + effectReplace(322) + effectReplace(323) + effectReplace(324) + effectReplace(325) + effectReplace(326) + effectReplace(327) } diff --git a/src/ff8/battle/trace.h b/src/ff8/battle/trace.h index e69de29b..bf262056 100644 --- a/src/ff8/battle/trace.h +++ b/src/ff8/battle/trace.h @@ -0,0 +1,26 @@ +/****************************************************************************/ +// Copyright (C) 2009 Aali132 // +// Copyright (C) 2018 quantumpencil // +// Copyright (C) 2018 Maxime Bacoux // +// Copyright (C) 2020 Chris Rizzitello // +// Copyright (C) 2020 John Pritchard // +// Copyright (C) 2024 myst6re // +// Copyright (C) 2024 Julian Xhokaxhiu // +// Copyright (C) 2023 Cosmos // +// Copyright (C) 2023 Tang-Tang Zhou // +// // +// This file is part of FFNx // +// // +// FFNx is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 3 of the License // +// // +// FFNx is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +/****************************************************************************/ + +#pragma once + +void battle_trace_init(); diff --git a/src/ff8/vram.cpp b/src/ff8/vram.cpp index 51d36e58..1c04e598 100644 --- a/src/ff8/vram.cpp +++ b/src/ff8/vram.cpp @@ -32,6 +32,7 @@ #include "world/wmset.h" #include "battle/stage.h" #include "file.h" +#include "battle/trace.h" #include #include @@ -71,6 +72,24 @@ std::unordered_map wm_wmset_palette_animations_ char battle_texture_name[MAX_PATH] = ""; int battle_texture_id = 0; Stage stage; +struct BattleTextureHeader { + uint8_t effect_id; + uint8_t file_id; + uint8_t is_palette; + uint8_t file_relative_id; + int16_t x, y; + int16_t w, h; + uint8_t *data; +}; +constexpr int battle_texture_data_list_size = 32; +std::vector battle_texture_headers = std::vector(battle_texture_data_list_size); +int battle_texture_headers_cursor = 0; +struct BattleTextureFileName { + char file_name[32]; + void *data; +}; +std::vector battle_texture_data_list = std::vector(battle_texture_data_list_size); +int battle_texture_data_list_cursor = 0; uint8_t *ff8_vram_seek(int xBpp2, int y) { @@ -1059,17 +1078,9 @@ void ff8_field_effects_upload_vram1(int16_t *pos_and_size, uint8_t *texture_buff texturePacker.setTexture(texture_name, TexturePacker::TextureInfos(pos_and_size[0], pos_and_size[1], pos_and_size[2], pos_and_size[3] * 2, bpp)); } -struct BattleTextureFileName { - char file_name[32]; - void *data; -}; - -std::vector battle_texture_data_list = std::vector(32); -int battle_texture_data_list_cursor = 0; - int battle_get_texture_file_name_index(void *texture_buffer) { - for (int i = 0; i < 32; ++i) { + for (int i = 0; i < battle_texture_data_list_size; ++i) { if (battle_texture_data_list.at(i).data == texture_buffer) { return i; } @@ -1080,8 +1091,9 @@ int battle_get_texture_file_name_index(void *texture_buffer) int16_t ff8_battle_open_and_read_file(int fileId, void *data, int a3, int callback) { - if (trace_all || trace_vram) ffnx_trace("%s: %d\n", __func__, fileId); + if (trace_all || trace_vram) ffnx_trace("%s: %d => %s\n", __func__, fileId, ff8_externals.battle_filenames[fileId]); + battle_texture_id = 0; if (stricmp(ff8_externals.battle_filenames[fileId], "B0WAVE.DAT") == 0) { // Fix redundant texture strncpy(battle_texture_name, "battle/A8DEF.TIM", sizeof(battle_texture_name)); @@ -1098,7 +1110,7 @@ int16_t ff8_battle_open_and_read_file(int fileId, void *data, int a3, int callba if (index < 0) { battle_texture_data_list[battle_texture_data_list_cursor] = tex; - battle_texture_data_list_cursor = (battle_texture_data_list_cursor + 1) % 32; + battle_texture_data_list_cursor = (battle_texture_data_list_cursor + 1) % battle_texture_data_list_size; } else { battle_texture_data_list[index] = tex; } @@ -1110,6 +1122,7 @@ void *ff8_battle_open_effect(const char *fileName, void *data, int dataSize, DWO { if (trace_all || trace_vram) ffnx_trace("%s: %s\n", __func__, fileName); + battle_texture_id = -1; snprintf(battle_texture_name, sizeof(battle_texture_name), "magic/%s", fileName); return ((void *(*)(const char*,void*,int,DWORD*))ff8_externals.load_magic_data_sub_571900)(fileName, data, dataSize, outSize); @@ -1119,8 +1132,6 @@ size_t ff8_battle_read_file(char *fileName, void *data) { if (trace_all || trace_vram) ffnx_trace("%s: %s\n", __func__, fileName); - battle_texture_id = 0; - size_t file_size = ff8_externals.sm_pc_read(fileName, data); if (save_textures && StrStrIA(fileName, ".X") != nullptr) { @@ -1130,24 +1141,9 @@ size_t ff8_battle_read_file(char *fileName, void *data) return file_size; } -int unknown_battle_texture_id = 0; - -struct BattleTextureHeader { - uint8_t effect_id; - uint8_t file_id; - uint8_t is_palette; - uint8_t file_relative_id; - int16_t x, y; - int16_t w, h; - uint8_t *data; -}; - -std::vector battle_texture_headers = std::vector(32); -int battle_texture_headers_cursor = 0; - int battle_get_texture_header_index(uint8_t *texture_buffer) { - for (int i = 0; i < 32; ++i) { + for (int i = 0; i < battle_texture_data_list_size; ++i) { if (battle_texture_headers.at(i).data == texture_buffer) { return i; } @@ -1156,6 +1152,20 @@ int battle_get_texture_header_index(uint8_t *texture_buffer) return -1; } +void battle_read_effect_alloc() +{ + int read_effect_magic_id = *(int *)0x1D99740; + if (trace_all || trace_vram) ffnx_trace("%s: effect_id=%d\n", __func__, read_effect_magic_id); + + // Reset list + for (int i = 0; i < battle_texture_headers.size(); ++i) { + battle_texture_headers[i] = BattleTextureHeader(); + } + battle_texture_headers_cursor = 0; + + ((void(*)())0x571BF0)(); +} + void battle_set_texture_header(uint8_t file_id, bool is_palette, uint8_t file_relative_id, int16_t *pos_and_size, uint8_t *texture_buffer) { int battle_read_effect_magic_id_dword_1D99740 = *(int *)0x1D99740; @@ -1180,7 +1190,7 @@ void battle_set_texture_header(uint8_t file_id, bool is_palette, uint8_t file_re if (index < 0) { battle_texture_headers[battle_texture_headers_cursor] = header; - battle_texture_headers_cursor = (battle_texture_headers_cursor + 1) % 32; + battle_texture_headers_cursor = (battle_texture_headers_cursor + 1) % battle_texture_data_list_size; } else { battle_texture_headers[index] = header; } @@ -1231,15 +1241,18 @@ void ff8_battle_upload_texture(int16_t *pos_and_size, uint8_t *texture_buffer) if (index >= 0) { const BattleTextureHeader &header = battle_texture_headers.at(index); - ffnx_info("%s: contains headers! size=(%d, %d)\n", __func__, header.w, header.h); + + if (trace_all || trace_vram) ffnx_trace("%s: texture identified is_pal=%d rect=(%d, %d, %d, %d) effect_id=%d file_id=%d file_relative_id=%d\n", __func__, + header.is_palette, header.x, header.y, header.w, header.h, header.effect_id, header.file_id, header.file_relative_id); + if (header.is_palette) { next_pal_data = (uint16_t *)texture_buffer; } else { uint16_t minX = 0xFFFF, maxX = 0, minY = 0xFFFF, maxY = 0; int index2 = index; - for (int i = 1; i < 32; ++i) { - const BattleTextureHeader &header2 = battle_texture_headers.at((index + i) % 32); + for (int i = 1; i < battle_texture_data_list_size; ++i) { + const BattleTextureHeader &header2 = battle_texture_headers.at((index + i) % battle_texture_data_list_size); if (!header2.is_palette) { break; } @@ -1258,7 +1271,6 @@ void ff8_battle_upload_texture(int16_t *pos_and_size, uint8_t *texture_buffer) } } - ffnx_trace("%s: min(%d, %d) max(%d, %d)\n", __func__, minX, minY, maxX, maxY); snprintf(next_texture_name, sizeof(next_texture_name), "magic/MAG%03d_B.%02d-%d", header.effect_id, header.file_id, header.file_relative_id); if (minY != 0xFFFF) { @@ -1267,8 +1279,8 @@ void ff8_battle_upload_texture(int16_t *pos_and_size, uint8_t *texture_buffer) palette_infos = TexturePacker::TextureInfos(minX, minY, maxX - minX, maxY - minY, next_bpp); int last_pal_x = -1, last_pal_y = -1; - for (int i = 1; i < 32; ++i) { - const BattleTextureHeader &header2 = battle_texture_headers.at((index + i) % 32); + for (int i = 1; i < battle_texture_data_list_size; ++i) { + const BattleTextureHeader &header2 = battle_texture_headers.at((index + i) % battle_texture_data_list_size); if (!header2.is_palette || (last_pal_y >= 0 && std::abs(header2.y - last_pal_y) > 10) || (last_pal_x >= 0 && last_pal_x != header.x)) { break; } @@ -1287,7 +1299,7 @@ void ff8_battle_upload_texture(int16_t *pos_and_size, uint8_t *texture_buffer) // We assume that the first palette is correct, so we remove it from the array. The others maybe not, so keep them if (i == 1) { - battle_texture_headers[(index + i) % 32] = BattleTextureHeader(); + battle_texture_headers[(index + i) % battle_texture_data_list_size] = BattleTextureHeader(); } } } else { @@ -1300,7 +1312,7 @@ void ff8_battle_upload_texture(int16_t *pos_and_size, uint8_t *texture_buffer) int index = battle_get_texture_file_name_index(texture_buffer); if (index >= 0) { - ffnx_trace("%s: texture data identified 0x%X\n", __func__, texture_buffer); + if (trace_all || trace_vram) ffnx_trace("%s: texture data identified 0x%X\n", __func__, texture_buffer); strncpy(next_texture_name, battle_texture_data_list[index].file_name, sizeof(battle_texture_data_list[index].file_name)); @@ -1323,8 +1335,8 @@ void ff8_battle_upload_texture(int16_t *pos_and_size, uint8_t *texture_buffer) Tim(next_bpp, tim_infos).save(next_texture_name); // Save with every palettes we know - for (int i = 1; i < 32; ++i) { - const BattleTextureHeader &header = battle_texture_headers.at(i % 32); + for (int i = 1; i < battle_texture_data_list_size; ++i) { + const BattleTextureHeader &header = battle_texture_headers.at(i % battle_texture_data_list_size); if (!header.is_palette) { continue; } @@ -1338,78 +1350,41 @@ void ff8_battle_upload_texture(int16_t *pos_and_size, uint8_t *texture_buffer) tim_infos.pal_h = header.h; Tim(next_bpp, tim_infos).save(fileName, true); } - } else { - ff8_tim tim_infos = ff8_tim(); - tim_infos.img_data = texture_buffer; - tim_infos.img_x = pos_and_size[0]; - tim_infos.img_y = pos_and_size[1]; - tim_infos.img_w = pos_and_size[2]; - tim_infos.img_h = pos_and_size[3]; - next_bpp = Tim::Bpp8; - snprintf(next_texture_name, sizeof(next_texture_name), "battle/unknown-%d", unknown_battle_texture_id); - Tim tim(next_bpp, tim_infos); - - tim.save(next_texture_name, true); - snprintf(next_texture_name, sizeof(next_texture_name), "battle/unknown-%d.tim", unknown_battle_texture_id); + } else if (trace_all || trace_vram) { + ffnx_warning("%s: unknown texture uploaded\n", __func__); } } - ++unknown_battle_texture_id; - ff8_upload_vram(pos_and_size, texture_buffer); } -struct battle_texture_item { - uint8_t type; - uint8_t field_1; - uint8_t field_2; - uint8_t field_3; - int16_t x, y, w, h; - char *texture_data; -}; - -battle_texture_item *battle_set_texture_action_upload1_sub_5057A0(int16_t *pos_and_size, char *texture_data) -{ - int *current_texture_dword_1D980F8 = (int *)0x1D980F8; - battle_texture_item *thing1D97EF8 = (battle_texture_item *)0x1D97EF8; - - ffnx_trace("%s: pos=(%d, %d) size=(%d, %d) texture_data=0x%X current_texture_dword_1D980F8=%d thing1D97EF8=0x%X\n", __func__, pos_and_size[0], pos_and_size[1], pos_and_size[2], pos_and_size[3], texture_data, *current_texture_dword_1D980F8, thing1D97EF8); - - battle_texture_item *result = &(thing1D97EF8[(*current_texture_dword_1D980F8)++]); - if (*current_texture_dword_1D980F8 < 32) - { - result->type = 0; - result->x = pos_and_size[0]; - result->y = pos_and_size[1]; - result->w = pos_and_size[2]; - result->h = pos_and_size[3]; - result->texture_data = texture_data; - } - return result; -} - -battle_texture_item *battle_set_texture_action_upload1_sub_5057A0_pal_call(int16_t *pos_and_size, char *texture_data) +void *battle_set_texture_action_upload1_sub_5057A0_pal_call(int16_t *pos_and_size, char *texture_data) { ffnx_trace("%s: pos=(%d, %d) size=(%d, %d) texture_data=0x%X\n", __func__, pos_and_size[0], pos_and_size[1], pos_and_size[2], pos_and_size[3], texture_data); battle_set_texture_header(0, true, 0, pos_and_size, (uint8_t *)texture_data); - return battle_set_texture_action_upload1_sub_5057A0(pos_and_size, texture_data); + return ((void*(*)(int16_t*,char*))0x5057A0)(pos_and_size, texture_data); } void ff8_battle_upload_texture_palette(int16_t *pos_and_size, uint8_t *texture_buffer) { - if (trace_all || trace_vram) ffnx_trace("%s: %s\n", __func__, battle_texture_name); + if (trace_all || trace_vram) ffnx_trace("%s: %s battle_texture_id=%d\n", __func__, battle_texture_name, battle_texture_id); Tim tim = Tim::fromTimData(texture_buffer - 20); next_pal_data = (uint16_t *)texture_buffer; ff8_upload_vram(pos_and_size, texture_buffer); + texture_infos = TexturePacker::TextureInfos(tim.imageX(), tim.imageY(), tim.imageWidth(), tim.imageHeight(), tim.bpp()); + palette_infos = TexturePacker::TextureInfos(tim.paletteX(), tim.paletteY(), tim.paletteWidth(), tim.paletteHeight(), Tim::Bpp16); next_bpp = tim.bpp(); - snprintf(next_texture_name, sizeof(next_texture_name), "%s-%d", battle_texture_name, battle_texture_id); - - ++battle_texture_id; + if (battle_texture_id < 0) { + strncpy(next_texture_name, battle_texture_name, sizeof(next_texture_name)); + } else { + snprintf(next_texture_name, sizeof(next_texture_name), "%s-%d", battle_texture_name, battle_texture_id); + ++battle_texture_id; + } if (save_textures) { if (StrStrIA(battle_texture_name, ".X") != nullptr) { @@ -1427,9 +1402,7 @@ void engine_set_init_time(double fps_adjust) palette_infos = TexturePacker::TextureInfos(); texture_infos = TexturePacker::TextureInfos(); - ffnx_info("%s: %llf\n", __func__, fps_adjust); - - ((void(*)(double))ff8_externals.engine_set_init_time)(60.5); + ((void(*)(double))ff8_externals.engine_set_init_time)(fps_adjust); } void clean_psxvram_pages() @@ -1488,8 +1461,8 @@ void vram_init() replace_call(ff8_externals.battle_open_file_wrapper + 0x14, ff8_battle_open_and_read_file); replace_call(ff8_externals.battle_open_file + 0x8E, ff8_battle_read_file); replace_call(ff8_externals.battle_open_file + 0x1A2, ff8_battle_read_file); + replace_call(0x50A8D0 + 0x63, battle_read_effect_alloc); replace_call(0x5056D0 + 0x2E, ff8_battle_upload_texture); - replace_function(0x5057A0, battle_set_texture_action_upload1_sub_5057A0); replace_function(0xB668E0, set_texture_data_from_mag000_maybe_palette_sub_B668E0); replace_function(0xB66820, fill_27972FC_with_texture_data_sub_B66820); replace_call(0xB66780 + 0x68, battle_set_texture_action_upload1_sub_5057A0_pal_call); @@ -1535,7 +1508,9 @@ void vram_init() //---- Misc // Fix missing textures in battle module by clearing custom textures - // replace_call(ff8_externals.battle_enter + 0x35, engine_set_init_time); + replace_call(ff8_externals.battle_enter + 0x35, engine_set_init_time); // Clear texture_packer on every module exits replace_call(ff8_externals.psxvram_texture_pages_free + 0x5A, clean_psxvram_pages); + + battle_trace_init(); } diff --git a/src/ff8_opengl.cpp b/src/ff8_opengl.cpp index fff129e8..7a544d07 100644 --- a/src/ff8_opengl.cpp +++ b/src/ff8_opengl.cpp @@ -275,16 +275,14 @@ void ff8_unload_texture(struct ff8_texture_set *texture_set) for(i = 0; i < TEXRELOAD_BUFFER_SIZE; i++) if(reload_buffer[i].texture_set == texture_set) reload_buffer[i].texture_set = 0; } -struct tex_header *last_tex_header = nullptr; - void swirl_sub_56D390(uint32_t x, uint32_t y, uint32_t w, uint32_t h) { + static struct tex_header *last_tex_header = 0; struct tex_header *tex_header = make_framebuffer_tex(256, 256, x, y, w, h, false); - if(last_tex_header) { - ff8_destroy_tex_header((struct ff8_tex_header *)last_tex_header); - last_tex_header = nullptr; - } + if(last_tex_header) ff8_destroy_tex_header((struct ff8_tex_header *)last_tex_header); + + if(trace_all) ffnx_trace("swirl_sub_56D390: (%i, %i) %ix%i 0x%x (0x%x)\n", x, y, w, h, *ff8_externals.swirl_texture1, tex_header); common_unload_texture((*ff8_externals.swirl_texture1)->hundred_data->texture_set); common_load_texture((*ff8_externals.swirl_texture1)->hundred_data->texture_set, tex_header, texture_format); @@ -518,7 +516,6 @@ int ff8_draw_gamepad_icon_or_keyboard_key(int a1, ff8_draw_menu_sprite_texture_i // Keep the "keys" if it is a keyboard and not a gamepad if (icon_id >= 128 && icon_id < 140) { - ffnx_trace("%s\n", __func__); BYTE is_gamepad = *ff8_externals.engine_gamepad_button_pressed != 0; if (is_gamepad) @@ -627,39 +624,30 @@ ff8_draw_menu_sprite_texture_infos *ff8_draw_icon_or_key( ff8_draw_menu_sprite_texture_infos *ff8_draw_icon_or_key1(int a1, ff8_draw_menu_sprite_texture_infos *draw_infos, int icon_id, uint16_t x, uint16_t y, int a6) { - ffnx_trace("%s\n", __func__); return ff8_draw_icon_or_key(a1, draw_infos, icon_id, x, y, a6); } ff8_draw_menu_sprite_texture_infos *ff8_draw_icon_or_key2(int a1, ff8_draw_menu_sprite_texture_infos *draw_infos, int *icon_sp1_data, int icon_id, uint16_t x, uint16_t y) { - ffnx_trace("%s\n", __func__); return ff8_draw_icon_or_key(a1, draw_infos, icon_id, x, y, *ff8_externals.dword_1D2B808); } ff8_draw_menu_sprite_texture_infos *ff8_draw_icon_or_key3(int a1, ff8_draw_menu_sprite_texture_infos *draw_infos, int *icon_sp1_data, int icon_id, uint16_t x, uint16_t y, int a6) { - ffnx_trace("%s\n", __func__); return ff8_draw_icon_or_key(a1, draw_infos, icon_id, x, y, a6, 0, true); } ff8_draw_menu_sprite_texture_infos *ff8_draw_icon_or_key4(int a1, ff8_draw_menu_sprite_texture_infos *draw_infos, int *icon_sp1_data, int icon_id, uint16_t x, uint16_t y, int a6, int a7) { - ffnx_trace("%s\n", __func__); return ff8_draw_icon_or_key(a1, draw_infos, icon_id, x, y, a6, a7, false, true); } ff8_draw_menu_sprite_texture_infos *ff8_draw_icon_or_key5(int a1, ff8_draw_menu_sprite_texture_infos *draw_infos, int icon_id, uint16_t x, uint16_t y, int a6, int a7) { - ffnx_trace("%s\n", __func__); - if (icon_id >= 128 && icon_id < 140) { - *(int *)0xFFFFFFFF = 0; - } return ff8_draw_icon_or_key(a1, draw_infos, icon_id, x, y, a6, a7, true); } ff8_draw_menu_sprite_texture_infos_short *ff8_draw_icon_or_key6(int a1, ff8_draw_menu_sprite_texture_infos_short *draw_infos, int icon_id, uint16_t x, uint16_t y, int a6, int a7) { - ffnx_trace("%s\n", __func__); // We should not cast like this, but that's what the game does icon_id = ff8_draw_gamepad_icon_or_keyboard_key(a1, reinterpret_cast(draw_infos), icon_id, x, y); if (icon_id < 0) @@ -898,377 +886,6 @@ int ff8_create_save_file_chocobo_world(int unused, int data_source, int offset, return ret; } -void toto(void *a1) -{ - ffnx_trace("%s\n", __func__); -} - -void toto5(void *a1, void *a2, void *a3, void *a4, void *a5) -{ - ffnx_trace("%s\n", __func__); - *((int*)0x1CA8528) = 0; -} - -bool insidecall = false; - -void toot(int a1, int a2) -{ - ffnx_trace("%s\n", __func__); - //ff8_vram_save("vram1.png", Tim::Bpp16); - - //insidecall = true; - - *(int*)0x1CA8528 = 0; // Disable software snapshot to VRAM - - ((void(*)(int,int))0x5595C0)(a1, a2); - ffnx_trace("/%s\n", __func__); - - //insidecall = false; - //ff8_vram_save("vram2.png", Tim::Bpp16); - - //*(int*)0xFFFFFFF = 1; -} - -void toot3(int16_t *a1) -{ - ffnx_trace("%s\n", __func__); - if (insidecall) { - ff8_vram_save("vram1a.png", Tim::Bpp16); - } - ((void(*)(int16_t*))0x45B660)(a1); - if (insidecall) { - ff8_vram_save("vram1b.png", Tim::Bpp16); - } -} - -void toot4(int color, void *pos_and_size, uint8_t r, uint8_t g, uint8_t b) -{ - ffnx_trace("%s\n", __func__); - if (insidecall) { - ff8_vram_save("vram1c.png", Tim::Bpp16); - } - ((void(*)(int,void*,uint8_t,uint8_t,uint8_t))0x45BED0)(color, pos_and_size, r, g, b); - if (insidecall) { - ff8_vram_save("vram1d.png", Tim::Bpp16); - } -} - -void toot5(void *a1) -{ - ffnx_trace("%s\n", __func__); - if (insidecall) { - ff8_vram_save("vram1e.png", Tim::Bpp16); - } - ((void(*)(void*))0x45D600)(a1); - ffnx_trace("/%s\n", __func__); - if (insidecall) { - ff8_vram_save("vram1f.png", Tim::Bpp16); - } -} - -void toot2() -{ - ffnx_trace("%s\n", __func__); - ff8_vram_save("vram.png", Tim::Bpp16); - - *(int*)0xFFFFFFF = 1; -} - -char vramFileName[MAX_PATH] = {}; -int vramId = 0; - -void toto2(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466EE0)(a1); -} - -void toto32(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4667B0)(a1); -} - -void toto33(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4667B0)(a1); -} - -void toto34(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4667B0)(a1); -} - -void toto35(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4667B0)(a1); -} - -void toto36(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4669E0)(a1); -} - -void toto37(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4669E0)(a1); -} - -void toto38(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4669E0)(a1); -} - -void toto39(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4669E0)(a1); -} - -void toto40(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4668E0)(a1); -} - -void toto41(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4668E0)(a1); -} - -void toto42(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4668E0)(a1); -} - -void toto43(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4668E0)(a1); -} - -void toto44(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466B00)(a1); -} - -void toto45(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466B00)(a1); -} - -void toto46(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466B00)(a1); -} - -void toto47(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466B00)(a1); -} - -void toto52(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466C60)(a1); -} - -void toto53(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466C60)(a1); -} - -void toto54(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466C60)(a1); -} - -void toto55(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466C60)(a1); -} - -void toto60(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466D80)(a1); -} - -void toto61(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466D80)(a1); -} - -void toto62(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466D80)(a1); -} - -void toto63(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x466D80)(a1); -} - -void toto128(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4670C0)(a1); -} - -void toto225(void *a1) { ffnx_trace("%s\n", __func__); - if (insidecall) { - snprintf(vramFileName, sizeof(vramFileName), "vram%d.png", vramId++); - ff8_vram_save(vramFileName, Tim::Bpp16); - } - ((void(*)(void*))0x4670F0)(a1); -} - -uint32_t currentFrame = 0; - -void engine_set_init_time(double fps_adjust) -{ - ffnx_info("%s: %llf\n", __func__, fps_adjust); - - currentFrame = 0; - - ((void(*)(double))ff8_externals.engine_set_init_time)(60.5); -} - -int check_active_window_battle() -{ - //*(int *)0xB6D970 = 0; // Disable sleep completely - int ret = ff8_is_window_active(); - - ffnx_trace("%s: %d %d\n", __func__, ret, currentFrame); - - if (ret) { - currentFrame = (currentFrame + 1) % 4; - } - - return ret; -} - -void battle_loop() -{ - ffnx_trace("%s: currentFrame=%d mode=%d mode3_substep=%d mode3_subsubstep=%d mode3_subsubsubcondition=%d mode3_subsubsubstep=%d to_update_flags=%X mode_1CDBCB8=%X\n", __func__, currentFrame, *(int *)0x1CD8C9E, *(int *)0x1CFF514, *(int *)0x1CFF520, *(int *)0x1D277E4, *(int *)0x1D277DC, *(int *)0x1D96774, *(uint16_t *)0x1CDBCB8); - - if (currentFrame == 0) { - if (*(uint16_t *)0x1CDBCB8 == 3) { - // Render menu - ((void(*)(int))0x4A7050)((int)0x1D966A0 + 92 * *(uint8_t *)0x1D96758); - // Input - ((void(*)())0x4A87A0)(); - ((void(*)())0x4A7E50)(); - } - - ((void(*)())0x47CCA0)(); - } else if (*(int *)0x1CFF520 && (*(int *)0x1D96774 & 4) != 0) { - ffnx_trace("%s: no render\n", __func__); - //((void(*)())0x4FFD50)(); - // Do not draw frame - //((ff8_game_obj *)common_externals.get_game_object())->field_A48 = 0; - //((void(*)())0x45B590)(); - if (*(uint16_t *)0x1CDBCB8 == 3) { - // Render menu - ((void(*)(int))0x4A7050)((int)0x1D966A0 + 92 * *(uint8_t *)0x1D96758); - // Input - ((void(*)())0x4A87A0)(); - ((void(*)())0x4A7E50)(); - } - ((void(*)(void *))0x45D600)((void *)0xFFFFFFFF); - // ((void(*)(void *))0x45D600)(&(*(DWORD **)0x1D8DD30)[4386 * (*(uint8_t *)0x1D96758) + 4385]); - } - - ffnx_trace("/%s: mode=%d mode3_substep=%d mode3_subsubstep=%d mode3_subsubsubcondition=%d mode3_subsubsubstep=%d to_update_flags=%X mode_1CDBCB8=%X\n", __func__, *(int *)0x1CD8C9E, *(int *)0x1CFF514, *(int *)0x1CFF520, *(int *)0x1D277E4, *(int *)0x1D277DC, *(int *)0x1D96774, *(uint16_t *)0x1CDBCB8); -} - -void battle_noop() -{ - -} - -void battle_noop2(int a1) -{ - -} - -int reset_thing_input_related_battle() -{ - currentFrame = (currentFrame + 1) % 4; - - return ((int(*)())0x56DD40)(); -} - void ff8_init_hooks(struct game_obj *_game_object) { struct ff8_game_obj *game_object = (struct ff8_game_obj *)_game_object; @@ -1284,72 +901,7 @@ void ff8_init_hooks(struct game_obj *_game_object) replace_function(ff8_externals.engine_eval_process_input, ff8_is_window_active); - - replace_call(0x47CF50 + 0x11B, battle_noop); - replace_call(0x47CF50 + 0x120, battle_noop); - replace_call(0x47CF50 + 0x125, battle_noop); - - replace_call(0x47CF50 + 0x1B3, battle_loop); - replace_call(0x47CF50 + 0x1D9, battle_noop2); - replace_call(0x47CF50 + 0x13D, battle_noop); - replace_call(0x47CF50 + 0x147, battle_noop); - replace_call(0x47CF50 + 0x142, battle_noop); - replace_call(0x47CF50 + 0x14C, battle_noop); - replace_call(0x47CF50 + 0x151, battle_noop); - replace_call(0x47CF50 + 0x156, battle_noop); - replace_call(0x47CF50 + 0x1D9, battle_noop2); - replace_call(0x47CF50 + 0x1E1, battle_noop); - replace_call(0x47CF50 + 0x1E6, battle_noop); - - replace_call(ff8_externals.battle_enter + 0x35, engine_set_init_time); - replace_call(0x47CF50 + 0x15B, check_active_window_battle); - replace_call(0x47CF50 + 0x2E3, reset_thing_input_related_battle); - - /*uint32_t *functs = (uint32_t*)0xB7DC18; - functs[2] = uint32_t(toto2); - functs[32] = uint32_t(toto32); - functs[33] = uint32_t(toto33); - functs[34] = uint32_t(toto34); - functs[35] = uint32_t(toto35); - functs[36] = uint32_t(toto36); - functs[37] = uint32_t(toto37); - functs[38] = uint32_t(toto38); - functs[39] = uint32_t(toto39); - - functs[40] = uint32_t(toto40); - functs[41] = uint32_t(toto41); - functs[42] = uint32_t(toto42); - functs[43] = uint32_t(toto43); - functs[44] = uint32_t(toto44); - functs[45] = uint32_t(toto45); - functs[46] = uint32_t(toto46); - functs[47] = uint32_t(toto47); - - functs[52] = uint32_t(toto52); - functs[53] = uint32_t(toto53); - functs[54] = uint32_t(toto54); - functs[55] = uint32_t(toto55); - - functs[60] = uint32_t(toto60); - functs[61] = uint32_t(toto61); - functs[62] = uint32_t(toto62); - functs[63] = uint32_t(toto63); - - functs[128] = uint32_t(toto128); - functs[225] = uint32_t(toto225); */ - replace_function(ff8_externals.swirl_sub_56D390, swirl_sub_56D390); - //replace_function(0x463D40, toto); - //replace_call(0x53F630 + 0xB3A, toto); - //replace_call(0x5595C0 + 0x26B, toto); - //replace_call(0x5595C0 + 0x27A, toto); - //replace_call(0x5595C0 + 0x2C9, toto); - //replace_call(0x5595C0 + 0x2B1, toto5); - //replace_call(0x53EC20 + 0x16C, toot2); - //replace_call(0x53F630 + 0xB3A, toot); - //replace_call(0x5595C0 + 0x26B, toot3); - //replace_call(0x5595C0 + 0x2B1, toot4); - //replace_call(0x5595C0 + 0x2C9, toot5); replace_function(common_externals.destroy_tex_header, ff8_destroy_tex_header); replace_function(common_externals.load_tex_file, ff8_load_tex_file);