mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 11:26:18 -04:00
0b8b927315
Support rendering eyes with merc for both jak 1 and jak 2. For jak 1, everything should look the same, but merc will be used to draw eyes. This means that jak is now fully drawn with merc! For jak 2, eyes should draw, but there are still a few issues: - the tbp/clut ptr trick is used a lot for these eye textures, so there's a lot that use the wrong texture - I had to enable a bunch more "texture uploads" (basically emulating the ps2 texture system) in order to get the eyes to upload. It would be much better if the eye renderer could somehow grab the texture from the merc model info, skipping the vram addressing stuff entirely. I plan to return to this. - I disabled some sky draws in `sky-tng`. After turning on pris2 uploads, the sky flashed in a really annoying way.
508 lines
21 KiB
C++
508 lines
21 KiB
C++
#include "MercData.h"
|
|
|
|
#include "common/dma/gs.h"
|
|
|
|
#include "decompiler/ObjectFile/LinkedObjectFile.h"
|
|
#include "decompiler/util/DecompilerTypeSystem.h"
|
|
|
|
#include "third-party/fmt/core.h"
|
|
|
|
namespace decompiler {
|
|
|
|
void MercEyeCtrl::from_ref(TypedRef tr, const DecompilerTypeSystem& dts) {
|
|
eye_slot = read_plain_data_field<s8>(tr, "eye-slot", dts);
|
|
}
|
|
|
|
void MercCtrlHeader::from_ref(TypedRef tr, const DecompilerTypeSystem& dts) {
|
|
st_magic = read_plain_data_field<u32>(tr, "st-magic", dts);
|
|
xyz_scale = read_plain_data_field<float>(tr, "xyz-scale", dts);
|
|
st_out_a = read_plain_data_field<u32>(tr, "st-out-a", dts);
|
|
st_out_b = read_plain_data_field<u32>(tr, "st-out-b", dts);
|
|
st_vif_add = read_plain_data_field<u32>(tr, "st-vif-add", dts);
|
|
st_int_off = read_plain_data_field<u16>(tr, "st-int-off", dts);
|
|
st_int_scale = read_plain_data_field<u16>(tr, "st-int-scale", dts);
|
|
effect_count = read_plain_data_field<u32>(tr, "effect-count", dts);
|
|
blend_target_count = read_plain_data_field<u32>(tr, "blend-target-count", dts);
|
|
fragment_count = read_plain_data_field<u16>(tr, "fragment-count", dts);
|
|
tri_count = read_plain_data_field<u16>(tr, "tri-count", dts);
|
|
matrix_count = read_plain_data_field<u8>(tr, "matrix-count", dts);
|
|
shader_count = read_plain_data_field<u8>(tr, "shader-count", dts);
|
|
transform_vertex_count = read_plain_data_field<u16>(tr, "transform-vertex-count", dts);
|
|
dvert_count = read_plain_data_field<u16>(tr, "dvert-count", dts);
|
|
one_mat_count = read_plain_data_field<u16>(tr, "one-mat-count", dts);
|
|
two_mat_count = read_plain_data_field<u16>(tr, "two-mat-count", dts);
|
|
two_mat_reuse_count = read_plain_data_field<u16>(tr, "two-mat-reuse-count", dts);
|
|
three_mat_count = read_plain_data_field<u16>(tr, "three-mat-count", dts);
|
|
three_mat_reuse_count = read_plain_data_field<u16>(tr, "three-mat-reuse-count", dts);
|
|
shader_upload_count = read_plain_data_field<u8>(tr, "shader-upload-count", dts);
|
|
matrix_upload_count = read_plain_data_field<u8>(tr, "matrix-upload-count", dts);
|
|
same_copy_count = read_plain_data_field<u16>(tr, "same-copy-count", dts);
|
|
cross_copy_count = read_plain_data_field<u16>(tr, "cross-copy-count", dts);
|
|
num_verts = read_plain_data_field<u16>(tr, "num-verts", dts);
|
|
longest_edge = read_plain_data_field<float>(tr, "longest-edge", dts);
|
|
auto fr = get_field_ref(tr, "eye-ctrl", dts);
|
|
const auto& word = fr.data->words_by_seg.at(fr.seg).at(fr.byte_offset / 4);
|
|
if (word.kind() == LinkedWord::PTR) {
|
|
eye_ctrl.emplace();
|
|
eye_ctrl->from_ref(TypedRef(deref_label(fr), dts.ts.lookup_type("merc-eye-ctrl")), dts);
|
|
}
|
|
|
|
// todo masks
|
|
envmap_tint = read_plain_data_field<u32>(tr, "envmap-tint", dts);
|
|
needs_clip = read_plain_data_field<u8>(tr, "needs-clip", dts);
|
|
use_isometric = read_plain_data_field<u8>(tr, "use-isometric", dts);
|
|
use_attached_shader = read_plain_data_field<u8>(tr, "use-attached-shader", dts);
|
|
display_triangles = read_plain_data_field<u8>(tr, "display-triangles", dts);
|
|
death_vertex_skip = read_plain_data_field<u16>(tr, "death-vertex-skip", dts);
|
|
death_start_vertex = read_plain_data_field<u16>(tr, "death-start-vertex", dts);
|
|
death_effect = read_plain_data_field<u32>(tr, "death-effect", dts);
|
|
use_translucent = read_plain_data_field<u8>(tr, "use-translucent", dts);
|
|
display_this_fragment = read_plain_data_field<u8>(tr, "display-this-fragment", dts);
|
|
}
|
|
|
|
std::string MercCtrlHeader::print() const {
|
|
std::string result;
|
|
result += fmt::format(" xyz_scale: {}\n", xyz_scale);
|
|
result += fmt::format(" st_out_a: 0x{:x}\n", st_out_a);
|
|
result += fmt::format(" st_out_b: 0x{:x}\n", st_out_b);
|
|
result += fmt::format(" st_vif_add: 0x{:x}\n", st_vif_add);
|
|
result += fmt::format(" st_int_off: 0x{:x}\n", st_int_off);
|
|
result += fmt::format(" st_int_scale: {}\n", st_int_scale);
|
|
result += fmt::format(" effect_count: {}\n", effect_count);
|
|
result += fmt::format(" blend_target_count: {}\n", blend_target_count);
|
|
result += fmt::format(" fragment_count: {}\n", fragment_count);
|
|
result += fmt::format(" tri_count: {}\n", tri_count);
|
|
result += fmt::format(" matrix_count: {}\n", matrix_count);
|
|
result += fmt::format(" shader_count: {}\n", shader_count);
|
|
result += fmt::format(" transform_vertex_count: {}\n", transform_vertex_count);
|
|
result += fmt::format(" dvert_count: {}\n", dvert_count);
|
|
result += fmt::format(" one_mat_count: {}\n", one_mat_count);
|
|
result += fmt::format(" two_mat_count: {}\n", two_mat_count);
|
|
result += fmt::format(" two_mat_reuse_count: {}\n", two_mat_reuse_count);
|
|
result += fmt::format(" three_mat_count: {}\n", three_mat_count);
|
|
result += fmt::format(" three_mat_reuse_count: {}\n", three_mat_reuse_count);
|
|
result += fmt::format(" shader_upload_count: {}\n", shader_upload_count);
|
|
result += fmt::format(" matrix_upload_count: {}\n", matrix_upload_count);
|
|
result += fmt::format(" same_copy_count: {}\n", same_copy_count);
|
|
result += fmt::format(" cross_copy_count: {}\n", cross_copy_count);
|
|
result += fmt::format(" num_verts: {}\n", num_verts);
|
|
result += fmt::format(" longest_edge: {}\n", longest_edge);
|
|
result += fmt::format(" envmap_tint: {}\n", envmap_tint);
|
|
result += fmt::format(" needs_clip: {}\n", needs_clip);
|
|
result += fmt::format(" use_isometric: {}\n", use_isometric);
|
|
result += fmt::format(" use_attached_shader: {}\n", use_attached_shader);
|
|
result += fmt::format(" display_triangles: {}\n", display_triangles);
|
|
result += fmt::format(" death_vertex_skip: {}\n", death_vertex_skip);
|
|
result += fmt::format(" death_start_vertex: {}\n", death_start_vertex);
|
|
result += fmt::format(" death_effect: {}\n", death_effect);
|
|
result += fmt::format(" use_translucent: {}\n", use_translucent);
|
|
result += fmt::format(" display_this_fragment: {}\n", display_this_fragment);
|
|
return result;
|
|
}
|
|
|
|
TypedRef MercFragmentControl::from_ref(TypedRef tr, const DecompilerTypeSystem& dts) {
|
|
unsigned_four_count = read_plain_data_field<u8>(tr, "unsigned-four-count", dts);
|
|
lump_four_count = read_plain_data_field<u8>(tr, "lump-four-count", dts);
|
|
fp_qwc = read_plain_data_field<u8>(tr, "fp-qwc", dts);
|
|
mat_xfer_count = read_plain_data_field<u8>(tr, "mat-xfer-count", dts);
|
|
ASSERT(mat_xfer_count < 10);
|
|
Ref dest_data_ref = get_field_ref(tr, "mat-dest-data", dts);
|
|
for (u8 i = 0; i < mat_xfer_count; i++) {
|
|
auto& entry = mat_dest_data.emplace_back();
|
|
entry.matrix_number = deref_u8(dest_data_ref, i * 2);
|
|
entry.matrix_dest = deref_u8(dest_data_ref, i * 2 + 1);
|
|
}
|
|
|
|
tr.ref.byte_offset += (4 + 2 * mat_dest_data.size());
|
|
return tr;
|
|
}
|
|
|
|
void MercFpHeader::from_ref(TypedRef tr, const DecompilerTypeSystem& dts) {
|
|
x_add = read_plain_data_field<float>(tr, "x-add", dts);
|
|
y_add = read_plain_data_field<float>(tr, "y-add", dts);
|
|
z_add = read_plain_data_field<float>(tr, "z-add", dts);
|
|
|
|
shader_cnt = read_plain_data_field<u8>(tr, "shader-cnt", dts);
|
|
kick_info_offset = read_plain_data_field<u8>(tr, "kick-info-offset", dts);
|
|
kick_info_step = read_plain_data_field<u8>(tr, "kick-info-step", dts);
|
|
hword_cnt = read_plain_data_field<u8>(tr, "hword-cnt", dts);
|
|
}
|
|
|
|
std::string MercFpHeader::print() const {
|
|
std::string result;
|
|
result += fmt::format(" x_add: {}\n", x_add);
|
|
result += fmt::format(" y_add: {}\n", y_add);
|
|
result += fmt::format(" z_add: {}\n", z_add);
|
|
result += fmt::format(" shader_cnt: {}\n", shader_cnt);
|
|
result += fmt::format(" kick_info_offset: {}\n", kick_info_offset);
|
|
result += fmt::format(" kick_info_step: {}\n", kick_info_step);
|
|
result += fmt::format(" hword_cnt: {}\n", hword_cnt);
|
|
return result;
|
|
}
|
|
|
|
void MercByteHeader::from_ref(TypedRef tr, const DecompilerTypeSystem& dts) {
|
|
srcdest_off = read_plain_data_field<u8>(tr, "srcdest-off", dts);
|
|
rgba_off = read_plain_data_field<u8>(tr, "rgba-off", dts);
|
|
lump_off = read_plain_data_field<u8>(tr, "lump-off", dts);
|
|
fp_off = read_plain_data_field<u8>(tr, "fp-off", dts);
|
|
mat1_cnt = read_plain_data_field<u8>(tr, "mat1-cnt", dts);
|
|
mat2_cnt = read_plain_data_field<u8>(tr, "mat2-cnt", dts);
|
|
mat3_cnt = read_plain_data_field<u8>(tr, "mat3-cnt", dts);
|
|
samecopy_cnt = read_plain_data_field<u8>(tr, "samecopy-cnt", dts);
|
|
crosscopy_cnt = read_plain_data_field<u8>(tr, "crosscopy-cnt", dts);
|
|
strip_len = read_plain_data_field<u8>(tr, "strip-len", dts);
|
|
mm_quadword_fp_off = read_plain_data_field<u8>(tr, "mm-quadword-fp-off", dts);
|
|
mm_quadword_size = read_plain_data_field<u8>(tr, "mm-quadword-size", dts);
|
|
perc_off = read_plain_data_field<u8>(tr, "perc-off", dts);
|
|
|
|
auto ms = get_field_ref(tr, "perc-off", dts);
|
|
bool got_end = false;
|
|
for (int i = 0; i < MAT_SLOTS; i++) {
|
|
ms.byte_offset++;
|
|
mat_slot[i] = deref_u8(ms, 0);
|
|
if (mat_slot[i] == 128) {
|
|
got_end = true;
|
|
} else {
|
|
// ASSERT(!got_end);
|
|
if (got_end) {
|
|
// lg::print("got something after the end\n"); // todo, should investigate more
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string MercByteHeader::print() const {
|
|
std::string result;
|
|
result += fmt::format(" srcdest_off: {}\n", srcdest_off);
|
|
result += fmt::format(" rgba_off: {}\n", rgba_off);
|
|
result += fmt::format(" lump_off: {}\n", lump_off);
|
|
result += fmt::format(" fp_off: {}\n", fp_off);
|
|
result += fmt::format(" mat1_cnt: {}\n", mat1_cnt);
|
|
result += fmt::format(" mat2_cnt: {}\n", mat2_cnt);
|
|
result += fmt::format(" mat3_cnt: {}\n", mat3_cnt);
|
|
result += fmt::format(" samecopy_cnt: {}\n", samecopy_cnt);
|
|
result += fmt::format(" crosscopy_cnt: {}\n", crosscopy_cnt);
|
|
result += fmt::format(" strip_len: {}\n", strip_len);
|
|
result += fmt::format(" mm_quadword_fp_off: {}\n", mm_quadword_fp_off);
|
|
result += fmt::format(" mm_quadword_size: {}\n", mm_quadword_size);
|
|
result += fmt::format(" perc_off: {}\n", perc_off);
|
|
for (int i = 0; i < MAT_SLOTS; i++) {
|
|
result += fmt::format(" mat_slot[{}]: {}\n", i, mat_slot[i]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string MercFragmentControl::print() const {
|
|
std::string result;
|
|
result += fmt::format(" unsigned_four_count: {}\n", unsigned_four_count);
|
|
result += fmt::format(" lump_four_count: {}\n", lump_four_count);
|
|
result += fmt::format(" fp_qwc: {}\n", fp_qwc);
|
|
result += fmt::format(" mat_xfer_count: {}\n", mat_xfer_count);
|
|
for (u8 i = 0; i < mat_xfer_count; i++) {
|
|
result += fmt::format(" mat[{}] {} -> {}\n", i, mat_dest_data[i].matrix_number,
|
|
mat_dest_data[i].matrix_dest);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string MercShader::print() const {
|
|
std::string result;
|
|
result += fmt::format(" output_offset: {}\n", output_offset);
|
|
result += fmt::format(" strip_tag: 0x{:x}\n", next_strip_nloop);
|
|
return result;
|
|
}
|
|
|
|
MercShader make_shader(Ref& ref, bool expected_eop) {
|
|
// adgif0
|
|
MercShader shader;
|
|
u8 adgif0_addr = deref_u8(ref, 8);
|
|
ASSERT(adgif0_addr == (u8)GsRegisterAddress::TEX0_1);
|
|
shader.output_offset = deref_u32(ref, 3);
|
|
shader.tex0 = GsTex0(deref_u64(ref, 0));
|
|
ref.byte_offset += 16;
|
|
|
|
// adgif1
|
|
u8 adgif1_addr = deref_u8(ref, 8);
|
|
ASSERT(adgif1_addr == (u8)GsRegisterAddress::TEX1_1);
|
|
shader.tex1 = GsTex1(deref_u64(ref, 0));
|
|
u16 stash = deref_u32(ref, 3);
|
|
shader.original_tex = deref_u32(ref, 2);
|
|
shader.next_strip_nloop = stash & 0x7fff;
|
|
ASSERT((!!(stash & 0x8000)) == expected_eop); // set eop on last
|
|
ref.byte_offset += 16;
|
|
|
|
// adgif2
|
|
u8 adgif2_addr = deref_u8(ref, 8);
|
|
ASSERT(adgif2_addr == (u8)GsRegisterAddress::MIPTBP1_1);
|
|
ref.byte_offset += 16;
|
|
|
|
// adgif3
|
|
u8 adgif3_addr = deref_u8(ref, 8);
|
|
ASSERT(adgif3_addr == (u8)GsRegisterAddress::CLAMP_1);
|
|
shader.clamp = deref_u64(ref, 0);
|
|
ref.byte_offset += 16;
|
|
|
|
// adgif4
|
|
u8 adgif4_addr = deref_u8(ref, 8);
|
|
ASSERT(adgif4_addr == (u8)GsRegisterAddress::ALPHA_1);
|
|
shader.alpha = GsAlpha(deref_u64(ref, 0));
|
|
ref.byte_offset += 16;
|
|
return shader;
|
|
}
|
|
|
|
TypedRef MercFragment::from_ref(TypedRef tr,
|
|
const DecompilerTypeSystem& dts,
|
|
const MercFragmentControl& control,
|
|
const MercCtrlHeader& main_control) {
|
|
// lg::print("frag::from_ref:\n{}\n", control.print());
|
|
TypedRef byte_hdr(get_field_ref(tr, "header", dts), dts.ts.lookup_type("merc-byte-header"));
|
|
header.from_ref(byte_hdr, dts);
|
|
// lg::print("{}\n", header.print());
|
|
|
|
// all these offsets are super confusing.
|
|
// the DMA transfers require source and dest addresses/sized to have alignment of 16 bytes.
|
|
// so the data is padded.
|
|
// the transfers increase size by 4x due to VIF unpacking
|
|
// But transferring this padding exactly would result in up to 63 bytes of wasted space.
|
|
// so they cheat the destination pointers to be slightly overlapping so the next transfer
|
|
// overlaps the padding of the previous.
|
|
// as a result, the "in VU" offsets are different from "in main memory"
|
|
|
|
// let's figure it out from bones.gc asm
|
|
// u4
|
|
// lbu s0, 0(gp) (fragment.control.unsigned-four-count)
|
|
// daddiu v0, s0, 3
|
|
// srl v0, v0, 2
|
|
// dsll32 s0, v0, 4
|
|
// daddu t3, t2, s0
|
|
u32 my_u4_count = ((control.unsigned_four_count + 3) / 4) * 16;
|
|
// lg::print("my u4: {} ({} qwc)\n", my_u4_count, my_u4_count / 16);
|
|
for (u32 w = 0; w < my_u4_count / 4; w++) {
|
|
u32 val = deref_u32(tr.ref, w);
|
|
memcpy(unsigned_four_including_header.emplace_back().data(), &val, 4);
|
|
}
|
|
|
|
// l4
|
|
// lbu s2, 1(gp)
|
|
// daddiu s0, s2, 3
|
|
// srl s0, s0, 2
|
|
// dsll32 s2, s0, 4
|
|
u32 my_l4_count = my_u4_count + ((control.lump_four_count + 3) / 4) * 16;
|
|
// lg::print("my l4: {} ({} qwc)\n", my_l4_count, my_l4_count / 16);
|
|
// end of lump should align with mm (main memory?) fp off. which
|
|
// is used for accessing the fp data in main memory.
|
|
ASSERT(my_l4_count / 16 == header.mm_quadword_fp_off);
|
|
|
|
// row.x/y is st-vif-add from the merc-ctrl-header.
|
|
// row.z = 0x47800000, row.w = 0x4b010000
|
|
math::Vector<u32, 4> row(main_control.st_vif_add, main_control.st_vif_add, 0x47800000,
|
|
0x4b010000);
|
|
for (u32 w = my_u4_count / 4; w < my_l4_count / 4; w++) {
|
|
ASSERT((w * 4) < header.mm_quadword_fp_off * 16);
|
|
u32 val = deref_u32(tr.ref, w);
|
|
|
|
math::Vector<u8, 4> as_u8s;
|
|
memcpy(as_u8s.data(), &val, 4);
|
|
math::Vector<u32, 4> as_u32s = as_u8s.cast<u32>();
|
|
as_u32s += row;
|
|
memcpy(lump4_unpacked.emplace_back().data(), as_u32s.data(), 16);
|
|
}
|
|
|
|
// fp header
|
|
Ref fp_ref = tr.ref;
|
|
fp_ref.byte_offset += 16 * header.mm_quadword_fp_off;
|
|
fp_header.from_ref(TypedRef(fp_ref, dts.ts.lookup_type("merc-fp-header")), dts);
|
|
fp_ref.byte_offset += 16;
|
|
|
|
// fp shaders
|
|
for (int i = 0; i < fp_header.shader_cnt; i++) {
|
|
bool expected_eop = (i == fp_header.shader_cnt - 1);
|
|
shaders.push_back(make_shader(fp_ref, expected_eop));
|
|
}
|
|
|
|
tr.ref.byte_offset += (header.mm_quadword_size) * 16;
|
|
|
|
// let's verify the matrix slots here.
|
|
int used_matrix_slots = 0;
|
|
for (auto x : header.mat_slot) {
|
|
if (x) {
|
|
used_matrix_slots++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
ASSERT(used_matrix_slots == control.mat_xfer_count);
|
|
for (int i = 0; i < used_matrix_slots; i++) {
|
|
ASSERT(header.mat_slot[i] == control.mat_dest_data.at(i).matrix_dest);
|
|
}
|
|
|
|
return tr;
|
|
}
|
|
|
|
std::string MercFragment::print() const {
|
|
std::string result;
|
|
result += fmt::format(" + BYTE-HEADER\n");
|
|
result += header.print();
|
|
result += fmt::format(" + FP-HEADER\n");
|
|
result += fp_header.print();
|
|
for (const auto& shader : shaders) {
|
|
result += fmt::format(" + SHADER\n");
|
|
result += shader.print();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void MercEffect::from_ref(TypedRef tr,
|
|
const DecompilerTypeSystem& dts,
|
|
const MercCtrlHeader& main_control) {
|
|
effect_bits = read_plain_data_field<u8>(tr, "effect-bits", dts);
|
|
frag_count = read_plain_data_field<u16>(tr, "frag-count", dts);
|
|
blend_frag_count = read_plain_data_field<u16>(tr, "blend-frag-count", dts);
|
|
tri_count = read_plain_data_field<u16>(tr, "tri-count", dts);
|
|
dvert_count = read_plain_data_field<u16>(tr, "dvert-count", dts);
|
|
auto* type = dynamic_cast<StructureType*>(dts.ts.lookup_type("merc-effect"));
|
|
Field temp;
|
|
if (type->lookup_field("envmap-usage", &temp)) {
|
|
envmap_or_effect_usage = read_plain_data_field<u8>(tr, "envmap-usage", dts);
|
|
} else {
|
|
envmap_or_effect_usage = read_plain_data_field<u8>(tr, "effect-usage", dts);
|
|
}
|
|
|
|
if (type->lookup_field("texture-index", &temp)) {
|
|
texture_index = read_plain_data_field<u8>(tr, "texture-index", dts);
|
|
}
|
|
|
|
// do frag-ctrls
|
|
TypedRef fc(deref_label(get_field_ref(tr, "frag-ctrl", dts)),
|
|
dts.ts.lookup_type("merc-fragment-control"));
|
|
for (u32 i = 0; i < frag_count; i++) {
|
|
fc = frag_ctrl.emplace_back().from_ref(fc, dts);
|
|
}
|
|
|
|
// do actual frags
|
|
TypedRef f(deref_label(get_field_ref(tr, "frag-geo", dts)), dts.ts.lookup_type("merc-fragment"));
|
|
for (u32 i = 0; i < frag_count; i++) {
|
|
f = frag_geo.emplace_back().from_ref(f, dts, frag_ctrl.at(i), main_control);
|
|
}
|
|
|
|
// do blend ctrls
|
|
if (blend_frag_count) {
|
|
TypedRef bc(deref_label(get_field_ref(tr, "blend-ctrl", dts)),
|
|
dts.ts.lookup_type("merc-blend-ctrl"));
|
|
for (u32 i = 0; i < blend_frag_count; i++) {
|
|
bc = blend_ctrl.emplace_back().from_ref(bc, dts, main_control.blend_target_count);
|
|
}
|
|
}
|
|
|
|
// do extra info
|
|
auto fr = get_field_ref(tr, "extra-info", dts);
|
|
const auto& word = fr.data->words_by_seg.at(fr.seg).at(fr.byte_offset / 4);
|
|
if (word.kind() == LinkedWord::PTR) {
|
|
TypedRef mei(deref_label(fr), dts.ts.lookup_type("merc-extra-info"));
|
|
u8 shader_offset = read_plain_data_field<u8>(mei, "shader-offset", dts);
|
|
if (shader_offset) {
|
|
Ref r = mei.ref;
|
|
r.byte_offset += 16 * shader_offset;
|
|
extra_info.shader = make_shader(r, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string MercEffect::print() {
|
|
std::string result;
|
|
result += fmt::format(" effect_bits: {}\n", effect_bits);
|
|
result += fmt::format(" frag_count: {}\n", frag_count);
|
|
result += fmt::format(" blend_frag_count: {}\n", blend_frag_count);
|
|
result += fmt::format(" tri_count: {}\n", tri_count);
|
|
result += fmt::format(" dvert_count: {}\n", dvert_count);
|
|
result += fmt::format(" envmap_or_effect_usage: {}\n", envmap_or_effect_usage);
|
|
|
|
for (u32 i = 0; i < frag_count; i++) {
|
|
result += fmt::format(" +FRAGMENT {}\n", i);
|
|
result += fmt::format(" + CTRL\n");
|
|
result += frag_ctrl[i].print();
|
|
result += fmt::format(" + GEO\n");
|
|
result += frag_geo[i].print();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void MercCtrl::from_ref(TypedRef tr, const DecompilerTypeSystem& dts) {
|
|
name = read_string_field(tr, "name", dts, false);
|
|
num_joints = read_plain_data_field<s32>(tr, "num-joints", dts);
|
|
auto merc_ctrl_header_ref =
|
|
TypedRef(get_field_ref(tr, "header", dts), dts.ts.lookup_type("merc-ctrl-header"));
|
|
header.from_ref(merc_ctrl_header_ref, dts);
|
|
|
|
auto eff_ref = TypedRef(get_field_ref(tr, "effect", dts), dts.ts.lookup_type("merc-effect"));
|
|
for (u32 i = 0; i < header.effect_count; i++) {
|
|
effects.emplace_back().from_ref(eff_ref, dts, header);
|
|
eff_ref.ref.byte_offset += 32; //
|
|
}
|
|
|
|
// debug_print_blerc();
|
|
}
|
|
|
|
void MercCtrl::debug_print_blerc() {
|
|
int total_verts = 0;
|
|
int blerc_verts = 0;
|
|
int total_frags = 0;
|
|
int blerc_frags = 0;
|
|
int total_effects = effects.size();
|
|
int blerc_effects = 0;
|
|
|
|
for (auto& effect : effects) {
|
|
bool effect_has_blerc = false;
|
|
for (size_t frag_idx = 0; frag_idx < effect.frag_count; frag_idx++) {
|
|
total_frags++;
|
|
auto& fc = effect.frag_ctrl.at(frag_idx);
|
|
total_verts += fc.lump_four_count;
|
|
|
|
if (frag_idx < effect.blend_ctrl.size()) {
|
|
auto& bfc = effect.blend_ctrl.at(frag_idx);
|
|
if (bfc.blend_vtx_count) {
|
|
effect_has_blerc = true;
|
|
blerc_frags++;
|
|
blerc_verts += fc.lump_four_count;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (effect_has_blerc) {
|
|
blerc_effects++;
|
|
}
|
|
}
|
|
if (blerc_effects) {
|
|
fmt::print("BLERC: {}, {}/{} e, {}/{} f, {}/{} v\n", name, blerc_effects, total_effects,
|
|
blerc_frags, total_frags, blerc_verts, total_verts);
|
|
}
|
|
}
|
|
|
|
TypedRef MercBlendCtrl::from_ref(TypedRef tr,
|
|
const DecompilerTypeSystem& dts,
|
|
int blend_target_count) {
|
|
blend_vtx_count = read_plain_data_field<u8>(tr, "blend-vtx-count", dts);
|
|
nonzero_index_count = read_plain_data_field<u8>(tr, "nonzero-index-count", dts);
|
|
tr.ref.byte_offset += 2;
|
|
for (int i = 0; i < blend_target_count; i++) {
|
|
bt_index.push_back(deref_u8(tr.ref, 0));
|
|
tr.ref.byte_offset += 1;
|
|
}
|
|
return tr;
|
|
}
|
|
|
|
std::string MercCtrl::print() {
|
|
std::string result;
|
|
result += fmt::format("name: {}\n", name);
|
|
result += fmt::format("num_joints: {}\n", num_joints);
|
|
result += "+ HEADER\n";
|
|
result += header.print();
|
|
result += "\n";
|
|
for (auto& eff : effects) {
|
|
result += fmt::format("+ EFFECT\n{}\n", eff.print());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
} // namespace decompiler
|