From 80cefb9575d7fb817949746b902afccf045f9817 Mon Sep 17 00:00:00 2001 From: water111 <48171810+water111@users.noreply.github.com> Date: Sat, 24 Sep 2022 14:30:44 -0400 Subject: [PATCH] [decomp] background and tfrag (#1909) --- decompiler/config/jak2/all-types.gc | 659 +++++++------- decompiler/config/jak2/hacks.jsonc | 4 +- decompiler/config/jak2/inputs.jsonc | 14 +- decompiler/config/jak2/label_types.jsonc | 1 + decompiler/config/jak2/type_casts.jsonc | 79 +- decompiler/config/jak2_ntsc_v1.jsonc | 2 +- decompiler/level_extractor/BspHeader.cpp | 13 +- decompiler/level_extractor/extract_level.cpp | 18 +- decompiler/level_extractor/extract_tie.cpp | 9 +- decompiler/types2/ForwardProp.cpp | 12 +- .../opengl_renderer/OpenGLRenderer.cpp | 7 + .../opengl_renderer/background/TFragment.cpp | 8 +- game/graphics/opengl_renderer/buckets.h | 10 +- .../opengl_renderer/shaders/tfrag3.vert | 2 +- .../shaders/tfrag3_no_tex.vert | 2 +- game/kernel/jak2/kmachine.cpp | 15 +- goal_src/jak2/dgos/cta.gd | 13 + goal_src/jak2/dgos/cwi.gd | 68 ++ goal_src/jak2/engine/debug/memory-usage-h.gc | 8 + goal_src/jak2/engine/draw/draw-node.gc | 43 + goal_src/jak2/engine/draw/drawable-h.gc | 2 +- goal_src/jak2/engine/draw/drawable.gc | 29 +- .../jak2/engine/gfx/background/background.gc | 544 +++++++++++ .../jak2/engine/gfx/background/prototype-h.gc | 1 + goal_src/jak2/engine/gfx/background/wind-h.gc | 3 + goal_src/jak2/engine/gfx/hw/display-h.gc | 4 +- goal_src/jak2/engine/gfx/merc/merc.gc | 2 +- goal_src/jak2/engine/gfx/shrub/shrubbery.gc | 12 +- goal_src/jak2/engine/gfx/texture/texture.gc | 9 +- goal_src/jak2/engine/gfx/tfrag/tfrag-h.gc | 7 + .../jak2/engine/gfx/tfrag/tfrag-methods.gc | 846 ++++++++++++++++++ goal_src/jak2/engine/gfx/tfrag/tfrag-near.gc | 68 ++ goal_src/jak2/engine/gfx/tfrag/tfrag-work.gc | 34 + goal_src/jak2/engine/gfx/tfrag/tfrag.gc | 504 +++++++++++ goal_src/jak2/engine/gfx/vu1-user-h.gc | 538 +++++------ goal_src/jak2/engine/level/bsp-h.gc | 17 +- goal_src/jak2/engine/level/level-h.gc | 1 + goal_src/jak2/engine/level/level.gc | 42 +- goal_src/jak2/engine/util/profile.gc | 72 +- goal_src/jak2/game.gp | 104 ++- goal_src/jak2/kernel-defs.gc | 1 + goal_src/jak2/kernel/gcommon.gc | 8 + goal_src/jak2/kernel/gkernel-h.gc | 5 + .../engine/gfx/background/tfrag-work_REF.gc | 45 + .../jak2/engine/gfx/hw/display-h_REF.gc | 12 +- .../jak2/engine/gfx/merc/merc_REF.gc | 2 +- .../jak2/engine/gfx/shrub/shrubbery_REF.gc | 12 +- .../jak2/engine/gfx/texture/texture_REF.gc | 7 +- .../jak2/engine/gfx/tfrag/tfrag-h_REF.gc | 5 +- .../jak2/engine/gfx/tfrag/tfrag-near_REF.gc | 76 ++ .../reference/jak2/engine/level/bsp-h_REF.gc | 13 +- .../reference/jak2/engine/level/bsp_REF.gc | 46 +- .../jak2/engine/level/level-h_REF.gc | 1 + .../reference/jak2/engine/util/profile_REF.gc | 72 +- test/offline/config/jak2/config.jsonc | 1 + 55 files changed, 3346 insertions(+), 786 deletions(-) create mode 100644 goal_src/jak2/dgos/cta.gd create mode 100644 goal_src/jak2/dgos/cwi.gd create mode 100644 test/decompiler/reference/jak2/engine/gfx/background/tfrag-work_REF.gc create mode 100644 test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-near_REF.gc diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc index 0b3a0a3666..fa5add9ef4 100644 --- a/decompiler/config/jak2/all-types.gc +++ b/decompiler/config/jak2/all-types.gc @@ -2719,10 +2719,10 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (tex-l0-tfrag 7) ;; level 0 tex - (bucket-8 8) ;; tfrag + (tfrag-l0-tfrag 8) ;; tfrag (bucket-9 9) ;; tie (bucket-10 10) ;; tie - (bucket-11 11) ;; tfrag + (tfrag-s-l0-tfrag 11) ;; tfrag (bucket-12 12) ;; tie (bucket-13 13) ;; tie (merc-l0-tfrag 14) ;; merc @@ -2731,10 +2731,10 @@ (bucket-17 17) ;; tie (tex-l1-tfrag 18) ;; tex - (bucket-19 19) ;; tfrag + (tfrag-l1-tfrag 19) ;; tfrag (bucket-20 20) ;; tie (bucket-21 21) ;; tie - (bucket-22 22) ;; tfrag + (tfrag-s-l1-tfrag 22) ;; tfrag (bucket-23 23) ;; tie (bucket-24 24) ;; tie (merc-l1-tfrag 25) ;; merc @@ -2743,10 +2743,10 @@ (bucket-28 28) ;; tie (tex-l2-tfrag 29) ;; tex - (bucket-30 30) ;; tfrag + (tfrag-l2-tfrag 30) ;; tfrag (bucket-31 31) ;; tie (bucket-32 32) ;; tie - (bucket-33 33) ;; tfrag + (tfrag-s-l2-tfrag 33) ;; tfrag (bucket-34 34) ;; tie (bucket-35 35) ;; tie (merc-l2-tfrag 36) ;; merc @@ -2755,10 +2755,10 @@ (bucket-39 39) ;; tie (tex-l3-tfrag 40) ;; tex - (bucket-41 41) ;; tfrag + (tfrag-l3-tfrag 41) ;; tfrag (bucket-42 42) ;; tie (bucket-43 43) ;; tie - (bucket-44 44) ;; tfrag + (tfrag-s-l3-tfrag 44) ;; tfrag (bucket-45 45) ;; tie (bucket-46 46) ;; tie (merc-l3-tfrag 47) ;; merc @@ -2767,10 +2767,10 @@ (bucket-50 50) ;; tie (tex-l4-tfrag 51) ;; tex - (bucket-52 52) ;; tfrag + (tfrag-l4-tfrag 52) ;; tfrag (bucket-53 53) ;; tie (bucket-54 54) ;; tie - (bucket-55 55) ;; tfrag + (tfrag-s-l4-tfrag 55) ;; tfrag (bucket-56 56) ;; tie (bucket-57 57) ;; tie (merc-l4-tfrag 58) ;; merc @@ -2779,10 +2779,10 @@ (bucket-61 61) ;; tie (tex-l5-tfrag 62) ;; tex - (bucket-63 63) ;; tfrag + (tfrag-l5-tfrag 63) ;; tfrag (bucket-64 64) ;; tie (bucket-65 65) ;; tie - (bucket-66 66) ;; tfrag + (tfrag-s-l5-tfrag 66) ;; tfrag (bucket-67 67) ;; tie (bucket-68 68) ;; tie (merc-l5-tfrag 69) ;; merc @@ -2794,299 +2794,299 @@ ;; All levels with shrub tpage ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - (tex-l0-shrub 73) ;; tex - (bucket-74 74) ;; shrub - (bucket-75 75) ;; shrub - (bucket-76 76) ;; shrub - (bucket-77 77) ;; shrub - (bucket-78 78) ;; shrub - (merc-l0-shrub 79) ;; merc - (emerc-l0-shrub 80) ;; emerc - (bucket-81 81) ;; mercneric + (tex-l0-shrub 73) ;; tex + (bucket-74 74) ;; shrub + (bucket-75 75) ;; shrub + (bucket-76 76) ;; shrub + (bucket-77 77) ;; shrub + (bucket-78 78) ;; shrub + (merc-l0-shrub 79) ;; merc + (emerc-l0-shrub 80) ;; emerc + (bucket-81 81) ;; mercneric - (tex-l1-shrub 82) ;; tex - (bucket-83 83) ;; shrub - (bucket-84 84) ;; shrub - (bucket-85 85) ;; shrub - (bucket-86 86) ;; shrub - (bucket-87 87) ;; shrub - (merc-l1-shrub 88) ;; merc - (emerc-l1-shrub 89) ;; emerc - (bucket-90 90) ;; mercneric + (tex-l1-shrub 82) ;; tex + (bucket-83 83) ;; shrub + (bucket-84 84) ;; shrub + (bucket-85 85) ;; shrub + (bucket-86 86) ;; shrub + (bucket-87 87) ;; shrub + (merc-l1-shrub 88) ;; merc + (emerc-l1-shrub 89) ;; emerc + (bucket-90 90) ;; mercneric - (tex-l2-shrub 91) ;; tex - (bucket-92 92) ;; shrub - (bucket-93 93) ;; shrub - (bucket-94 94) ;; shrub - (bucket-95 95) ;; shrub - (bucket-96 96) ;; shrub - (merc-l2-shrub 97) ;; merc - (emerc-l2-shrub 98) ;; emerc - (bucket-99 99) ;; mercneric + (tex-l2-shrub 91) ;; tex + (bucket-92 92) ;; shrub + (bucket-93 93) ;; shrub + (bucket-94 94) ;; shrub + (bucket-95 95) ;; shrub + (bucket-96 96) ;; shrub + (merc-l2-shrub 97) ;; merc + (emerc-l2-shrub 98) ;; emerc + (bucket-99 99) ;; mercneric - (tex-l3-shrub 100) ;; tex - (bucket-101 101) ;; shrub - (bucket-102 102) ;; shrub - (bucket-103 103) ;; shrub - (bucket-104 104) ;; shrub - (bucket-105 105) ;; shrub - (merc-l3-shrub 106) ;; merc - (emerc-l3-shrub 107) ;; emerc - (bucket-108 108) ;; mercneric + (tex-l3-shrub 100) ;; tex + (bucket-101 101) ;; shrub + (bucket-102 102) ;; shrub + (bucket-103 103) ;; shrub + (bucket-104 104) ;; shrub + (bucket-105 105) ;; shrub + (merc-l3-shrub 106) ;; merc + (emerc-l3-shrub 107) ;; emerc + (bucket-108 108) ;; mercneric - (tex-l4-shrub 109) ;; tex - (bucket-110 110) ;; shrub - (bucket-111 111) ;; shrub - (bucket-112 112) ;; shrub - (bucket-113 113) ;; shrub - (bucket-114 114) ;; shrub - (merc-l4-shrub 115) ;; merc - (emerc-l4-shrub 116) ;; emerc - (bucket-117 117) ;; mercneric + (tex-l4-shrub 109) ;; tex + (bucket-110 110) ;; shrub + (bucket-111 111) ;; shrub + (bucket-112 112) ;; shrub + (bucket-113 113) ;; shrub + (bucket-114 114) ;; shrub + (merc-l4-shrub 115) ;; merc + (emerc-l4-shrub 116) ;; emerc + (bucket-117 117) ;; mercneric - (tex-l5-shrub 118) ;; tex - (bucket-119 119) ;; shrub - (bucket-120 120) ;; shrub - (bucket-121 121) ;; shrub - (bucket-122 122) ;; shrub - (bucket-123 123) ;; shrub - (merc-l5-shrub 124) ;; merc - (emerc-l5-shrub 125) ;; emerc - (bucket-126 126) ;; mercneric + (tex-l5-shrub 118) ;; tex + (bucket-119 119) ;; shrub + (bucket-120 120) ;; shrub + (bucket-121 121) ;; shrub + (bucket-122 122) ;; shrub + (bucket-123 123) ;; shrub + (merc-l5-shrub 124) ;; merc + (emerc-l5-shrub 125) ;; emerc + (bucket-126 126) ;; mercneric - (tex-l0-alpha 127) ;; tex - (bucket-128 128) ;; tfrag - (bucket-129 129) ;; tie - (bucket-130 130) ;; tie - (merc-l0-alpha 131) ;; merc - (emerc-l0-alpha 132) ;; emerc - (bucket-133 133) ;; mercneric - (bucket-134 134) ;; tfrag - (bucket-135 135) ;; tie - (bucket-136 136) ;; tie + (tex-l0-alpha 127) ;; tex + (tfrag-t-l0-alpha 128) ;; tfrag + (bucket-129 129) ;; tie + (bucket-130 130) ;; tie + (merc-l0-alpha 131) ;; merc + (emerc-l0-alpha 132) ;; emerc + (bucket-133 133) ;; mercneric + (tfrag-st-l0-alpha 134) ;; tfrag + (bucket-135 135) ;; tie + (bucket-136 136) ;; tie - (tex-l1-alpha 137) ;; tex - (bucket-138 138) ;; tfrag - (bucket-139 139) ;; tie - (bucket-140 140) ;; tie - (merc-l1-alpha 141) ;; merc - (emerc-l1-alpha 142) ;; emerc - (bucket-143 143) ;; mercneric - (bucket-144 144) ;; tfrag - (bucket-145 145) ;; tie - (bucket-146 146) ;; tie + (tex-l1-alpha 137) ;; tex + (tfrag-t-l1-alpha 138) ;; tfrag + (bucket-139 139) ;; tie + (bucket-140 140) ;; tie + (merc-l1-alpha 141) ;; merc + (emerc-l1-alpha 142) ;; emerc + (bucket-143 143) ;; mercneric + (tfrag-st-l1-alpha 144) ;; tfrag + (bucket-145 145) ;; tie + (bucket-146 146) ;; tie - (tex-l2-alpha 147) ;; tex - (bucket-148 148) ;; tfrag - (bucket-149 149) ;; tie - (bucket-150 150) ;; tie - (merc-l2-alpha 151) ;; merc - (emerc-l2-alpha 152) ;; emerc - (bucket-153 153) ;; mercneric - (bucket-154 154) ;; tfrag - (bucket-155 155) ;; tie - (bucket-156 156) ;; tie + (tex-l2-alpha 147) ;; tex + (tfrag-t-l2-alpha 148) ;; tfrag + (bucket-149 149) ;; tie + (bucket-150 150) ;; tie + (merc-l2-alpha 151) ;; merc + (emerc-l2-alpha 152) ;; emerc + (bucket-153 153) ;; mercneric + (tfrag-st-l2-alpha 154) ;; tfrag + (bucket-155 155) ;; tie + (bucket-156 156) ;; tie - (tex-l3-alpha 157) ;; tex - (bucket-158 158) ;; tfrag - (bucket-159 159) ;; tie - (bucket-160 160) ;; tie - (merc-l3-alpha 161) ;; merc - (emerc-l3-alpha 162) ;; emerc - (bucket-163 163) ;; mercneric - (bucket-164 164) ;; tfrag - (bucket-165 165) ;; tie - (bucket-166 166) ;; tie + (tex-l3-alpha 157) ;; tex + (tfrag-t-l3-alpha 158) ;; tfrag + (bucket-159 159) ;; tie + (bucket-160 160) ;; tie + (merc-l3-alpha 161) ;; merc + (emerc-l3-alpha 162) ;; emerc + (bucket-163 163) ;; mercneric + (tfrag-st-l3-alpha 164) ;; tfrag + (bucket-165 165) ;; tie + (bucket-166 166) ;; tie - (tex-l4-alpha 167) ;; tex - (bucket-168 168) ;; tfrag - (bucket-169 169) ;; tie - (bucket-170 170) ;; tie - (merc-l4-alpha 171) ;; merc - (emerc-l4-alpha 172) ;; emerc - (bucket-173 173) ;; mercneric - (bucket-174 174) ;; tfrag - (bucket-175 175) ;; tie - (bucket-176 176) ;; tie + (tex-l4-alpha 167) ;; tex + (tfrag-t-l4-alpha 168) ;; tfrag + (bucket-169 169) ;; tie + (bucket-170 170) ;; tie + (merc-l4-alpha 171) ;; merc + (emerc-l4-alpha 172) ;; emerc + (bucket-173 173) ;; mercneric + (tfrag-st-l4-alpha 174) ;; tfrag + (bucket-175 175) ;; tie + (bucket-176 176) ;; tie - (tex-l5-alpha 177) ;; tex - (bucket-178 178) ;; tfrag - (bucket-179 179) ;; tie - (bucket-180 180) ;; tie - (merc-l5-alpha 181) ;; merc - (emerc-l5-alpha 182) ;; emerc - (bucket-183 183) ;; mercneric - (bucket-184 184) ;; tfrag - (bucket-185 185) ;; tie - (bucket-186 186) ;; tie + (tex-l5-alpha 177) ;; tex + (tfrag-t-l5-alpha 178) ;; tfrag + (bucket-179 179) ;; tie + (bucket-180 180) ;; tie + (merc-l5-alpha 181) ;; merc + (emerc-l5-alpha 182) ;; emerc + (bucket-183 183) ;; mercneric + (tfrag-st-l5-alpha 184) ;; tfrag + (bucket-185 185) ;; tie + (bucket-186 186) ;; tie - (tex-lcom-tfrag 187) ;; tex - (merc-lcom-tfrag 188) ;; merc - (emerc-lcom-tfrag 189) ;; emerc - (bucket-190 190) ;; mercneric + (tex-lcom-tfrag 187) ;; tex + (merc-lcom-tfrag 188) ;; merc + (emerc-lcom-tfrag 189) ;; emerc + (bucket-190 190) ;; mercneric - (tex-lcom-shrub 191) ;; tex - (merc-lcom-shrub 192) ;; merc - (emerc-lcom-shrub 193) ;; emerc - (bucket-194 194) ;; mercneric + (tex-lcom-shrub 191) ;; tex + (merc-lcom-shrub 192) ;; merc + (emerc-lcom-shrub 193) ;; emerc + (bucket-194 194) ;; mercneric - (bucket-195 195) ;; shadow + (bucket-195 195) ;; shadow - (tex-l0-pris 196) ;; tex - (merc-l0-pris 197) ;; merc - (emerc-l0-pris 198) ;; emerc - (bucket-199 199) ;; mercneric + (tex-l0-pris 196) ;; tex + (merc-l0-pris 197) ;; merc + (emerc-l0-pris 198) ;; emerc + (bucket-199 199) ;; mercneric - (tex-l1-pris 200) ;; tex - (merc-l1-pris 201) ;; merc - (emerc-l1-pris 202) ;; emerc - (bucket-203 203) ;; mercneric + (tex-l1-pris 200) ;; tex + (merc-l1-pris 201) ;; merc + (emerc-l1-pris 202) ;; emerc + (bucket-203 203) ;; mercneric - (tex-l2-pris 204) ;; tex - (merc-l2-pris 205) ;; merc - (emerc-l2-pris 206) ;; emerc - (bucket-207 207) ;; mercneric + (tex-l2-pris 204) ;; tex + (merc-l2-pris 205) ;; merc + (emerc-l2-pris 206) ;; emerc + (bucket-207 207) ;; mercneric - (tex-l3-pris 208) ;; tex - (merc-l3-pris 209) ;; merc - (emerc-l3-pris 210) ;; emerc - (bucket-211 211) ;; mercneric + (tex-l3-pris 208) ;; tex + (merc-l3-pris 209) ;; merc + (emerc-l3-pris 210) ;; emerc + (bucket-211 211) ;; mercneric - (tex-l4-pris 212) ;; tex - (merc-l4-pris 213) ;; merc - (emerc-l4-pris 214) ;; emerc - (bucket-215 215) ;; mercneric + (tex-l4-pris 212) ;; tex + (merc-l4-pris 213) ;; merc + (emerc-l4-pris 214) ;; emerc + (bucket-215 215) ;; mercneric - (tex-l5-pris 216) ;; tex - (merc-l5-pris 217) ;; merc - (emerc-l5-pris 218) ;; emerc - (bucket-219 219) ;; mercneric + (tex-l5-pris 216) ;; tex + (merc-l5-pris 217) ;; merc + (emerc-l5-pris 218) ;; emerc + (bucket-219 219) ;; mercneric - (tex-lcom-pris 220) ;; tex - (merc-lcom-pris 221) ;; merc - (emerc-lcom-pris 222) ;; emerc - (bucket-223 223) ;; mercneric + (tex-lcom-pris 220) ;; tex + (merc-lcom-pris 221) ;; merc + (emerc-lcom-pris 222) ;; emerc + (bucket-223 223) ;; mercneric - (tex-l0-pris2 224) ;; tex - (merc-l0-pris2 225) ;; merc - (emerc-l0-pris2 226) ;; emerc - (bucket-227 227) ;; mercneric + (tex-l0-pris2 224) ;; tex + (merc-l0-pris2 225) ;; merc + (emerc-l0-pris2 226) ;; emerc + (bucket-227 227) ;; mercneric - (tex-l1-pris2 228) ;; tex - (merc-l1-pris2 229) ;; merc - (emerc-l1-pris2 230) ;; emerc - (bucket-231 231) ;; mercneric + (tex-l1-pris2 228) ;; tex + (merc-l1-pris2 229) ;; merc + (emerc-l1-pris2 230) ;; emerc + (bucket-231 231) ;; mercneric - (tex-l2-pris2 232) ;; tex - (merc-l2-pris2 233) ;; merc - (emerc-l2-pris2 234) ;; emerc - (bucket-235 235) ;; mercneric + (tex-l2-pris2 232) ;; tex + (merc-l2-pris2 233) ;; merc + (emerc-l2-pris2 234) ;; emerc + (bucket-235 235) ;; mercneric - (tex-l3-pris2 236) ;; tex - (merc-l3-pris2 237) ;; merc - (emerc-l3-pris2 238) ;; emerc - (bucket-239 239) ;; mercneric + (tex-l3-pris2 236) ;; tex + (merc-l3-pris2 237) ;; merc + (emerc-l3-pris2 238) ;; emerc + (bucket-239 239) ;; mercneric - (tex-l4-pris2 240) ;; tex - (merc-l4-pris2 241) ;; merc - (emerc-l4-pris2 242) ;; emerc - (bucket-243 243) ;; mercneric + (tex-l4-pris2 240) ;; tex + (merc-l4-pris2 241) ;; merc + (emerc-l4-pris2 242) ;; emerc + (bucket-243 243) ;; mercneric - (tex-l5-pris2 244) ;; tex - (merc-l5-pris2 245) ;; merc - (emerc-l5-pris2 246) ;; emerc - (bucket-247 247) ;; mercneric + (tex-l5-pris2 244) ;; tex + (merc-l5-pris2 245) ;; merc + (emerc-l5-pris2 246) ;; emerc + (bucket-247 247) ;; mercneric - (tex-lcom-pris2 248) ;; tex - (merc-lcom-pris2 249) ;; merc - (emerc-lcom-pris2 250) ;; emerc - (bucket-251 251) ;; mercneric + (tex-lcom-pris2 248) ;; tex + (merc-lcom-pris2 249) ;; merc + (emerc-lcom-pris2 250) ;; emerc + (bucket-251 251) ;; mercneric - (tex-l0-water 252) ;; tex - (merc-l0-water 253) ;; merc - (bucket-254 254) ;; mercneric - (bucket-255 255) ;; tfrag - (bucket-256 256) - (bucket-257 257) - (bucket-258 258) - (bucket-259 259) ;; tfrag - (bucket-260 260) + (tex-l0-water 252) ;; tex + (merc-l0-water 253) ;; merc + (bucket-254 254) ;; mercneric + (tfrag-w-l0-water 255) ;; tfrag + (bucket-256 256) + (bucket-257 257) + (bucket-258 258) + (tfrag-ws-l0-water 259) ;; tfrag + (bucket-260 260) - (tex-l1-water 261) ;; tex - (merc-l1-water 262) ;; merc - (bucket-263 263) ;; mercneric - (bucket-264 264) ;; tfrag - (bucket-265 265) - (bucket-266 266) - (bucket-267 267) - (bucket-268 268) ;; tfrag - (bucket-269 269) + (tex-l1-water 261) ;; tex + (merc-l1-water 262) ;; merc + (bucket-263 263) ;; mercneric + (tfrag-w-l1-water 264) ;; tfrag + (bucket-265 265) + (bucket-266 266) + (bucket-267 267) + (tfrag-ws-l1-water 268) ;; tfrag + (bucket-269 269) - (tex-l2-water 270) ;; tex - (merc-l2-water 271) ;; merc - (bucket-272 272) ;; mercneric - (bucket-273 273) ;; tfrag - (bucket-274 274) - (bucket-275 275) - (bucket-276 276) - (bucket-277 277) ;; tfrag - (bucket-278 278) + (tex-l2-water 270) ;; tex + (merc-l2-water 271) ;; merc + (bucket-272 272) ;; mercneric + (tfrag-w-l2-water 273) ;; tfrag + (bucket-274 274) + (bucket-275 275) + (bucket-276 276) + (tfrag-ws-l2-water 277) ;; tfrag + (bucket-278 278) - (tex-l3-water 279) ;; tex - (merc-l3-water 280) ;; merc - (bucket-281 281) ;; mercneric - (bucket-282 282) ;; tfrag - (bucket-283 283) - (bucket-284 284) - (bucket-285 285) - (bucket-286 286) ;; tfrag - (bucket-287 287) + (tex-l3-water 279) ;; tex + (merc-l3-water 280) ;; merc + (bucket-281 281) ;; mercneric + (tfrag-w-l3-water 282) ;; tfrag + (bucket-283 283) + (bucket-284 284) + (bucket-285 285) + (tfrag-ws-l3-water 286) ;; tfrag + (bucket-287 287) - (tex-l4-water 288) ;; tex - (merc-l4-water 289) ;; merc - (bucket-290 290) ;; mercneric - (bucket-291 291) ;; tfrag - (bucket-292 292) - (bucket-293 293) - (bucket-294 294) - (bucket-295 295) ;; tfrag - (bucket-296 296) + (tex-l4-water 288) ;; tex + (merc-l4-water 289) ;; merc + (bucket-290 290) ;; mercneric + (tfrag-w-l4-water 291) ;; tfrag + (bucket-292 292) + (bucket-293 293) + (bucket-294 294) + (tfrag-ws-l4-water 295) ;; tfrag + (bucket-296 296) - (tex-l5-water 297) ;; tex - (merc-l5-water 298) ;; merc - (bucket-299 299) ;; mercneric - (bucket-300 300) ;; tfrag - (bucket-301 301) - (bucket-302 302) - (bucket-303 303) - (bucket-304 304) ;; tfrag - (bucket-305 305) + (tex-l5-water 297) ;; tex + (merc-l5-water 298) ;; merc + (bucket-299 299) ;; mercneric + (tfrag-w-l5-water 300) ;; tfrag + (bucket-301 301) + (bucket-302 302) + (bucket-303 303) + (tfrag-ws-l5-water 304) ;; tfrag + (bucket-305 305) - (tex-lcom-water 306) ;; tex - (merc-lcom-water 307) ;; merc - (bucket-308 308) ;; mercneric + (tex-lcom-water 306) ;; tex + (merc-lcom-water 307) ;; merc + (bucket-308 308) ;; mercneric - (tex-lcom-sky-post 309) + (tex-lcom-sky-post 309) - (bucket-310 310) ;; ocean - (bucket-311 311) ;; depth-cue + (bucket-310 310) ;; ocean + (bucket-311 311) ;; depth-cue - (tex-all-sprite 312) - (bucket-313 313) ;; particles - (bucket-314 314) ;; shadow - (bucket-315 315) ;; effects - (tex-all-warp 316) ;; tex - (bucket-317 317) ;; mercneric + (tex-all-sprite 312) + (bucket-313 313) ;; particles + (bucket-314 314) ;; shadow + (bucket-315 315) ;; effects + (tex-all-warp 316) ;; tex + (bucket-317 317) ;; mercneric - (debug-no-zbuf1 318) ;; debug, no zbuf - (tex-all-map 319) ;; tex - (bucket-320 320) ;; hud - (screen-filter 321) ;; hud letterbox, no zbuf - (bucket-322 322) ;; hud - (bucket-323 323) ;; hud - (debug2 324) ;; debug - (debug-no-zbuf2 325) ;; debug - (debug3 326) + (debug-no-zbuf1 318) ;; debug, no zbuf + (tex-all-map 319) ;; tex + (bucket-320 320) ;; hud + (screen-filter 321) ;; hud letterbox, no zbuf + (bucket-322 322) ;; hud + (bucket-323 323) ;; hud + (debug2 324) ;; debug + (debug-no-zbuf2 325) ;; debug + (debug3 326) ) ;; TODO - names in `render` menu @@ -3099,7 +3099,7 @@ (rn3) (rn4) (rn5) - (rn6) + (tfrag) (rn7) (rn8) (rn9) @@ -3112,12 +3112,12 @@ (rn16) (rn17) (rn18) - (rn19) + (tfrag-trans) (rn20) (rn21) (rn22) (rn23) - (rn24) + (tfrag-water) (rn25) (rn26) (rn27) @@ -4855,7 +4855,7 @@ (deftype texture-mask (structure) ((mask vector4w :inline :offset-assert 0) - (dist float :offset 12) + (dist float :offset 12 :score 1) (long uint64 2 :offset 0) (quad uint128 :offset 0) ) @@ -5899,6 +5899,7 @@ (water-masks texture-masks-array :offset-assert 5064) (water-dists pointer :offset-assert 5068) (tfrag-last-calls int32 6 :offset-assert 5072) + (tfrag-last-calls-u32 uint32 6 :offset 5072) ;; added (texture-anim-array texture-anim-array 10 :offset-assert 5096) (light-hash light-hash :offset-assert 5136) (draw-priority float :offset-assert 5140) @@ -7479,6 +7480,14 @@ (defenum mem-usage-id :bitfield #f :type uint32 + (tfragment 1) + (tfragment-base 2) + (tfragment-common 3) + (tfragment-level0 4) + (tfragment-level1 5) + (tfragment-color 6) + (tfragment-debug 7) + (entity 43) (camera 44) @@ -8022,7 +8031,7 @@ (draw (_type_ _type_ display-frame) none 10) (drawable-method-11 () none 11) ;; (collide-with-box (_type_ int collide-list) none 11) (drawable-method-12 () none 12) ;; (collide-y-probe (_type_ int collide-list) none 12) - (collect-stats (_type_) none 13) + (collect-stats (_type_) none 13) ;; (collide-ray (_type_ int collide-list) none 13) (debug-draw (_type_ drawable display-frame) none 14) (unpack-vis (_type_ (pointer int8) (pointer int8)) (pointer int8) 15) ;; (collect-regions (_type_ sphere int region-prim-list) none 16) @@ -17000,17 +17009,26 @@ (collide-hash collide-hash :offset-assert 196) ;; 200 is some array ;; 204 is maybe that array's length + (wind-array-length int32 :offset 204) ;; 216 is a vector array ;; (vec-array (pointer vector) :offset 216) ; TODO see - `update-visible` hits assertion (region-tree drawable-tree-region-prim :offset 252) + (tfrag-masks texture-masks-array :offset-assert 256) - (tfrag-mask-count uint32 :offset-assert 260) + (tfrag-closest (pointer float) :offset-assert 260) + (tfrag-mask-count uint32 :offset 260) + (shrub-masks texture-masks-array :offset-assert 264) - (shrub-mask-count uint32 :offset-assert 268) + (shrub-closest (pointer float) :offset-assert 268) + (shrub-mask-count uint32 :offset 268) + (alpha-masks texture-masks-array :offset-assert 272) - (alpha-mask-count uint32 :offset-assert 276) + (alpha-closest (pointer float) :offset-assert 276) + (alpha-mask-count uint32 :offset 276) + (water-masks texture-masks-array :offset-assert 280) - (water-mask-count uint32 :offset-assert 284) + (water-closest (pointer float) :offset-assert 284) + (water-mask-count uint32 :offset 284) (bsp-scale vector :inline :offset-assert 288) (bsp-offset vector :inline :offset-assert 304) @@ -17852,6 +17870,7 @@ (dma-base uint32 :offset 36) (dma-level-1 uint32 :offset 40) (dma-qwc uint8 4 :offset 44) ;; guessed by decompiler + (dma-u32 uint32 :offset 44) ;; added (shader (inline-array adgif-shader) :offset 48) ;; guessed by decompiler (num-shaders uint8 :offset 52) (num-base-colors uint8 :offset 53) @@ -21785,7 +21804,7 @@ (define-extern update-wind (function wind-work (array uint8) none)) ;; (define-extern wind-get-hashed-index function) ;; (function vector int) -;; (define-extern level-update-wind function) +(define-extern level-update-wind (function wind-work none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; bsp ;; @@ -22615,7 +22634,7 @@ (define-extern *generic-consts* generic-consts) ;; (define-extern generic-work-init function) ;; (function generic-dma-foreground-sink none) ;; (define-extern generic-upload-vu0 function) ;; (function none) -;; (define-extern upload-vu0-program function) ;; (function vu-function pointer none) +(define-extern upload-vu0-program (function vu-function pointer none)) ;; (define-extern generic-initialize-without-sync function) ;; (define-extern generic-initialize function) ;; (function generic-dma-foreground-sink matrix vu-lights none) ;; (define-extern generic-wrapup function) ;; (function generic-dma-foreground-sink none) @@ -22960,20 +22979,20 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (define-extern *background-work* background-work) -;; (define-extern background-vu0-block object) ;; vu-function -;; (define-extern background-upload-vu0 function) ;; (function none) +(define-extern background-vu0-block vu-function) +(define-extern background-upload-vu0 (function none)) (define-extern init-background (function none)) -;; (define-extern upload-vis-bits function) ;; (function level level bsp-header none) -;; (define-extern set-background-regs! function) -;; (define-extern set-tie-quard-planes! function) -;; (define-extern set-shrub-quard-planes! function) +(define-extern upload-vis-bits (function level level bsp-header none)) +(define-extern set-background-regs! (function level none)) +(define-extern set-tie-quard-planes! (function level none)) +(define-extern set-shrub-quard-planes! (function level none)) (define-extern finish-background (function none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; draw-node ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern draw-node-cull function) ;; (function pointer pointer (inline-array draw-node) int none) +(define-extern draw-node-cull (function pointer pointer (inline-array draw-node) int none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; shrubbery ;; @@ -23026,56 +23045,54 @@ ;; tfrag-near ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern tnear-vu1-block object) ;; vu-function -;; (define-extern tfrag-details function) ;; (function tfragment none) -;; (define-extern clip-restore function) ;; (function none) +(define-extern tnear-vu1-block vu-function) +(define-extern tfrag-details (function tfragment none)) +(define-extern clip-restore (function none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; tfrag ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern *tfrag-display-stats* object) ;; symbol -;; (define-extern tfrag-vu1-block object) ;; vu-function -;; (define-extern tfrag-data-setup function) ;; (function tfrag-data int none) -;; (define-extern add-tfrag-mtx-0 function) ;; (function dma-buffer none) -;; (define-extern add-tfrag-mtx-1 function) ;; (function dma-buffer none) -;; (define-extern add-tfrag-data function) ;; (function dma-buffer int none) -;; (define-extern t-stat object) ;; tfrag-stats -;; (define-extern tfrag-print-stats function) ;; (function symbol none) -;; (define-extern tfrag-init-buffer function) ;; (function dma-buffer gs-test int none) -;; (define-extern tfrag-end-buffer function) ;; (function dma-buffer none) -;; (define-extern draw-inline-array-tfrag function) ;; (function pointer drawable-inline-array int dma-buffer none) -;; (define-extern tfrag-scissor-init-buffer function) -;; (define-extern tfrag-scissor-end-buffer function) -;; (define-extern draw-inline-array-tfrag-scissor function) -;; (define-extern stats-tfrag-asm function) ;; (function tfragment none) +(define-extern *tfrag-display-stats* symbol) +(define-extern tfrag-vu1-block vu-function) +(define-extern tfrag-data-setup (function tfrag-data int int none)) +(define-extern add-tfrag-mtx-0 (function dma-buffer symbol none)) +(define-extern add-tfrag-mtx-1 (function dma-buffer symbol none)) +(define-extern add-tfrag-data (function dma-buffer int int none)) +(define-extern t-stat tfrag-stats) +(define-extern tfrag-print-stats (function symbol none)) +(define-extern tfrag-init-buffer (function dma-buffer gs-test int symbol none)) +(define-extern tfrag-end-buffer (function dma-buffer int none)) +(define-extern draw-inline-array-tfrag (function pointer drawable-inline-array int dma-buffer none)) +(define-extern tfrag-scissor-init-buffer (function dma-buffer gs-test int symbol none)) +(define-extern tfrag-scissor-end-buffer (function dma-buffer uint none)) +(define-extern draw-inline-array-tfrag-scissor (function pointer drawable-inline-array int dma-buffer none)) +(define-extern stats-tfrag-asm (function tfragment none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; tfrag-methods ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype tfrag-init-data (structure) - ((tfrag-bucket int32 :offset-assert 0) - (tfrag-scissor-bucket int32 :offset-assert 4) - (tfrag-trans-bucket int32 :offset-assert 8) - (tfrag-scissor-trans-bucket int32 :offset-assert 12) - (tfrag-water-bucket int32 :offset-assert 16) - (tfrag-water-scissor-bucket int32 :offset-assert 20) + ((tfrag-bucket bucket-id :offset-assert 0) + (tfrag-scissor-bucket bucket-id :offset-assert 4) + (tfrag-trans-bucket bucket-id :offset-assert 8) + (tfrag-scissor-trans-bucket bucket-id :offset-assert 12) + (tfrag-water-bucket bucket-id :offset-assert 16) + (tfrag-water-scissor-bucket bucket-id :offset-assert 20) ) :method-count-assert 9 :size-assert #x18 :flag-assert #x900000018 ) -|# -;; (define-extern edge-debug-lines function) ;; (function (array vector-array) none) -;; (define-extern draw-drawable-tree-tfrag function) ;; (function drawable-tree-tfrag none) -;; (define-extern draw-drawable-tree-tfrag-trans function) -;; (define-extern draw-drawable-tree-tfrag-water function) -;; (define-extern tfrag-vu1-init-buf function) -;; (define-extern tfrag-scissor-vu1-init-buf function) -;; (define-extern *tfrag-init-table* object) +(define-extern edge-debug-lines (function (array vector-array) none)) +(define-extern draw-drawable-tree-tfrag (function drawable-tree-tfrag none)) +(define-extern draw-drawable-tree-tfrag-trans (function drawable-tree-tfrag none)) +(define-extern draw-drawable-tree-tfrag-water (function drawable-tree-tfrag none)) +(define-extern tfrag-vu1-init-buf (function bucket-id gs-test int uint symbol none)) +(define-extern tfrag-scissor-vu1-init-buf (function bucket-id gs-test int uint symbol none)) +(define-extern *tfrag-init-table* (inline-array tfrag-init-data)) (define-extern tfrag-vu1-init-buffers (function none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -23276,7 +23293,7 @@ ;; (define-extern tie-near-init-consts function) ;; (function tie-near-consts int none) ;; (define-extern tie-near-init-engine function) ;; (function dma-buffer gs-test int none) ;; (define-extern tie-near-end-buffer function) ;; (function dma-buffer none) -;; (define-extern tie-scissor-make-perspective-matrix function) +(define-extern tie-scissor-make-perspective-matrix (function object object none)) ;; (define-extern tie-near-int-reg function) ;; (function int string) ;; (define-extern tie-near-float-reg function) ;; (function int string) @@ -23336,7 +23353,7 @@ ;; (define-extern draw-inline-array-instance-tie function) ;; (function pointer (inline-array instance-tie) int dma-buffer none) ;; (define-extern draw-inline-array-prototype-tie-asm function) ;; (function dma-buffer int prototype-array-tie none) ;; (define-extern instance-tie-patch-buckets function) -;; (define-extern draw-drawable-tree-instance-tie function) ;; (function drawable-tree-instance-tie level none) +(define-extern draw-drawable-tree-instance-tie (function drawable-tree-instance-tie level none)) ;; (define-extern tie-init-scissor-buf function) ;; (define-extern tie-init-buf function) ;; (define-extern tie-init-envmap-buf function) @@ -24736,8 +24753,8 @@ (define-extern init-time-of-day (function object :behavior time-of-day-proc)) ;; (define-extern start-time-of-day (function (pointer process))) (define-extern time-of-day-setup (function symbol symbol)) -;; (define-extern time-of-day-interp-colors function) ;; (function (pointer rgba) uint mood-context none) -;; (define-extern time-of-day-interp-colors-scratch function) ;; (function (pointer rgba) time-of-day-palette mood-context none) +(define-extern time-of-day-interp-colors (function (pointer rgba) uint mood-context none)) +(define-extern time-of-day-interp-colors-scratch (function (pointer rgba) time-of-day-palette mood-context none)) (define-extern init-time-of-day-context (function time-of-day-context symbol)) (define-extern set-filter-color! (function float float float none)) (define-extern tod-madd! (function vector vector vector float)) diff --git a/decompiler/config/jak2/hacks.jsonc b/decompiler/config/jak2/hacks.jsonc index 18e437f811..af309955f3 100644 --- a/decompiler/config/jak2/hacks.jsonc +++ b/decompiler/config/jak2/hacks.jsonc @@ -278,7 +278,9 @@ "draw-actor-marks": [8], "find-nearest-entity": [7, 9, 10, 11, 12, 13, 14], "start-perf-stat-collection": [26], - "end-perf-stat-collection": [0] + "end-perf-stat-collection": [0], + "upload-vis-bits": [2, 6, 3, 0], + "set-background-regs!":[4, 3] }, // Sometimes the game might use format strings that are fetched dynamically, diff --git a/decompiler/config/jak2/inputs.jsonc b/decompiler/config/jak2/inputs.jsonc index c7532cbb78..453e17762a 100644 --- a/decompiler/config/jak2/inputs.jsonc +++ b/decompiler/config/jak2/inputs.jsonc @@ -12,10 +12,10 @@ "CGO/KERNEL.CGO", "CGO/ENGINE.CGO", "CGO/GAME.CGO", - "CGO/COMMON.CGO" // , + "CGO/COMMON.CGO", // "DGO/LWIDEB.DGO", // "DGO/LMEETBRT.DGO", - // "DGO/CTA.DGO", + "DGO/CTA.DGO", // "DGO/PALOUT.DGO", // "DGO/STD.DGO", // "DGO/FOR.DGO", @@ -63,7 +63,7 @@ // "DGO/LTRNTESS.DGO", // "DGO/TBO.DGO", // "DGO/THR.DGO", - // "DGO/PRI.DGO", + "DGO/PRI.DGO", // "DGO/LKIDDOGE.DGO", // "DGO/NESTT.DGO", // "DGO/LWIDEC.DGO", @@ -148,7 +148,7 @@ // "DGO/UNB.DGO", // "DGO/CPO.DGO", // "DGO/CAP.DGO", - // "DGO/CWI.DGO", + "DGO/CWI.DGO" // "DGO/CTYKORA.DGO", // "DGO/RUI.DGO", // "DGO/LSACK.DGO", @@ -184,5 +184,9 @@ "streamed_audio_file_names": [], - "levels_to_extract": [] + "levels_to_extract": [ + "PRI.DGO", + "CTA.DGO", + "CWI.DGO" +] } diff --git a/decompiler/config/jak2/label_types.jsonc b/decompiler/config/jak2/label_types.jsonc index 4a676571a8..24e8404bcc 100644 --- a/decompiler/config/jak2/label_types.jsonc +++ b/decompiler/config/jak2/label_types.jsonc @@ -189,5 +189,6 @@ ["L896", "(pointer uint64)", 1], ["L897", "(pointer uint64)", 1] ], + "tfrag-methods": [["L119", "(inline-array tfrag-init-data)", 6]], "nav-mesh": [["L347", "(inline-array vector)", 2]] } diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc index 777bc4430a..230b5371bc 100644 --- a/decompiler/config/jak2/type_casts.jsonc +++ b/decompiler/config/jak2/type_casts.jsonc @@ -1563,7 +1563,7 @@ ], "(method 9 shrubbery)": [ [23, "a2", "(pointer int32)"], - [28, "a3", "(inline-array texture-masks)"] + [28, "a3", "(pointer int32)"] ], "init-dma-test": [[29, "v1", "(inline-array qword)"]], "drawable-load": [[[25, 28], "s5", "drawable"]], @@ -2309,6 +2309,12 @@ [123, "a1", "drawable-tree-instance-shrub"], [[129, 133], "a2", "(inline-array prototype-bucket-shrub)"] ], + + "(method 10 bsp-header)": [ + [43, "a1", "terrain-context"], + [31, "a0", "terrain-context"] + ], + "history-draw": [ [151, "a0", "uint"], ["_stack_", 24, "pat-surface"] @@ -2321,6 +2327,77 @@ [[42, 46], "t2", "(pointer int8)"] ], "(method 14 drawable-tree-array)": [[11, "s5", "drawable-tree-array"]], + "upload-vis-bits": [ + [14, "a1", "(pointer uint128)"] + ], + "set-background-regs!": [ + [42, "v1", "(pointer int32)"], + [47, "v1", "(pointer int32)"], + [45, "a0", "(pointer int32)"] + ], + "finish-background": [ + [752, "t0", "(pointer float)"], + [785, "t4", "(pointer int32)"], + [815, "t0", "(pointer float)"], + [848, "t4", "(pointer int32)"], + [878, "t0", "(pointer float)"], + [911, "t4", "(pointer int32)"], + [941, "a3", "(pointer float)"], + [974, "t3", "(pointer int32)"] + ], + "(method 16 drawable-inline-array-node)": [ + [[1,7], "v1", "draw-node"] + ], + "(method 9 tfragment)": [ + [27, "a3", "(pointer int32)"], + [32, "t0", "texture"] + ], + "add-tfrag-mtx-0": [ + [[3, 17], "a0", "dma-packet"] + ], + "add-tfrag-mtx-1": [ + [[3, 17], "a0", "dma-packet"] + ], + "add-tfrag-data": [ + [[3, 17], "a0", "dma-packet"], + [[24, 31], "v1", "dma-packet"] + ], + "tfrag-init-buffer": [ + [[10, 17], "a0", "dma-packet"], + [[19, 26], "a0", "gs-gif-tag"], + [31, "a0", "(pointer gs-reg64)"], + [[47, 55], "v1", "dma-packet"] + ], + "tfrag-end-buffer": [ + [[1, 8], "a2", "dma-packet"], + [[11, 18], "a0", "(pointer vif-tag)"], + [[18, 22], "a0", "(pointer int32)"], + [[23, 29], "a0", "(pointer vif-tag)"] + ], + "draw-drawable-tree-tfrag": [ + [17, "v1", "drawable-inline-array-node"], + [19, "a0", "drawable-inline-array-node"], + [[104, 110], "v1", "dma-packet"], + [[183, 189], "v1", "dma-packet"] + + ], + "draw-drawable-tree-tfrag-trans": [ + [18, "v1", "drawable-inline-array-node"], + [20, "a0", "drawable-inline-array-node"], + [[176, 182], "v1", "dma-packet"], + [[97, 103], "v1", "dma-packet"] + ], + "draw-drawable-tree-tfrag-water": [ + [18, "v1", "drawable-inline-array-node"], + [20, "a0", "drawable-inline-array-node"], + [[176, 182], "v1", "dma-packet"], + [[97, 103], "v1", "dma-packet"] + ], + "tfrag-vu1-init-buf": [ + [[27, 35], "v1", "dma-packet"], + [[61, 66], "v1", "dma-packet"], + [69, "v1", "(pointer int32)"] + ], // placeholder "placeholder-do-not-add-below": [] } diff --git a/decompiler/config/jak2_ntsc_v1.jsonc b/decompiler/config/jak2_ntsc_v1.jsonc index 873b2858fb..b029010592 100644 --- a/decompiler/config/jak2_ntsc_v1.jsonc +++ b/decompiler/config/jak2_ntsc_v1.jsonc @@ -99,7 +99,7 @@ //////////////////////////// // turn this on to extract level background graphics data - "levels_extract": false, + "levels_extract": true, // turn this on if you want extracted levels to be saved out as .obj files "rip_levels": false, // should we extract collision meshes? diff --git a/decompiler/level_extractor/BspHeader.cpp b/decompiler/level_extractor/BspHeader.cpp index 924faa2db3..8f9699d3ee 100644 --- a/decompiler/level_extractor/BspHeader.cpp +++ b/decompiler/level_extractor/BspHeader.cpp @@ -1355,7 +1355,6 @@ void DrawableTreeInstanceShrub::read_from_file(TypedRef ref, word.symbol_name() == "collide-hash-fragment") { done = true; } else { - fmt::print("unknown next thing: {}\n", word.symbol_name()); ASSERT(word.symbol_name() == "draw-node" || word.symbol_name() == "instance-shrubbery"); } } @@ -1779,10 +1778,14 @@ std::unique_ptr make_drawable_tree(TypedRef ref, return tree; } - if (ref.type->get_name() == "drawable-tree-instance-shrub") { - auto tree = std::make_unique(); - tree->read_from_file(ref, dts, stats, version); - return tree; + if (version == GameVersion::Jak2) { + lg::warn("skipping drawable-tree-instance-shrub reading for jak 2"); + } else { + if (ref.type->get_name() == "drawable-tree-instance-shrub") { + auto tree = std::make_unique(); + tree->read_from_file(ref, dts, stats, version); + return tree; + } } if (ref.type->get_name() == "drawable-tree-collide-fragment") { diff --git a/decompiler/level_extractor/extract_level.cpp b/decompiler/level_extractor/extract_level.cpp index 42af170472..dc432a7b1a 100644 --- a/decompiler/level_extractor/extract_level.cpp +++ b/decompiler/level_extractor/extract_level.cpp @@ -100,6 +100,10 @@ void extract_art_groups_from_level(const ObjectFileDB& db, const std::vector& tex_remap, const std::string& dgo_name, tfrag3::Level& level_data) { + if (db.version() == GameVersion::Jak2) { + lg::warn("skipping art group extraction for jak 2"); + return; + } const auto& files = db.obj_files_by_dgo.at(dgo_name); for (const auto& file : files) { if (file.name.length() > 3 && !file.name.compare(file.name.length() - 3, 3, "-ag")) { @@ -171,11 +175,15 @@ std::vector extract_bsp_from_level(const ObjectFileDB extract_tie(as_tie_tree, fmt::format("{}-{}-tie", dgo_name, i++), bsp_header.texture_remap_table, tex_db, level_data, false); } else if (draw_tree->my_type() == "drawable-tree-instance-shrub") { - auto as_shrub_tree = - dynamic_cast(draw_tree.get()); - ASSERT(as_shrub_tree); - extract_shrub(as_shrub_tree, fmt::format("{}-{}-shrub", dgo_name, i++), - bsp_header.texture_remap_table, tex_db, {}, level_data, false); + if (db.version() == GameVersion::Jak2) { + lg::warn("skipping drawable-tree-instance-shrub extraction for jak 2"); + } else { + auto as_shrub_tree = + dynamic_cast(draw_tree.get()); + ASSERT(as_shrub_tree); + extract_shrub(as_shrub_tree, fmt::format("{}-{}-shrub", dgo_name, i++), + bsp_header.texture_remap_table, tex_db, {}, level_data, false); + } } else if (draw_tree->my_type() == "drawable-tree-collide-fragment" && extract_collision) { auto as_collide_frags = dynamic_cast(draw_tree.get()); diff --git a/decompiler/level_extractor/extract_tie.cpp b/decompiler/level_extractor/extract_tie.cpp index acaeff9fac..45eb884db8 100644 --- a/decompiler/level_extractor/extract_tie.cpp +++ b/decompiler/level_extractor/extract_tie.cpp @@ -6,6 +6,9 @@ #include "decompiler/ObjectFile/LinkedObjectFile.h" +// Jak 2 notes: +// - proto flags are currently ignored, but stored. + namespace decompiler { /// @@ -339,6 +342,7 @@ struct TieProtoInfo { std::string name; std::vector instances; bool uses_generic = false; + u32 proto_flag; float stiffness = 0; // wind u32 generic_flag; std::vector time_of_day_colors; // c++ type for time of day data @@ -483,11 +487,10 @@ void update_proto_info(std::vector* out, for (size_t i = 0; i < protos.size(); i++) { const auto& proto = protos[i]; auto& info = out->at(i); - // the flags can either be 0 or 2. - ASSERT(proto.flags == 0 || proto.flags == 2); + info.proto_flag = proto.flags; // flag of 2 means it should use the generic renderer (determined from EE asm) // for now, we ignore this and use TIE on everything. - info.uses_generic = (proto.flags == 2); + info.uses_generic = (proto.flags == 2); // possibly different in jak 2 // for debug, remember the name info.name = proto.name; // wind "stiffness" nonzero value means it has the wind effect diff --git a/decompiler/types2/ForwardProp.cpp b/decompiler/types2/ForwardProp.cpp index d069ebdead..79e23116e9 100644 --- a/decompiler/types2/ForwardProp.cpp +++ b/decompiler/types2/ForwardProp.cpp @@ -261,10 +261,16 @@ bool backprop_tagged_type(const TP_Type& expected_type, case types2::Tag::BLOCK_ENTRY: // don't update if we're updating to exactly the same thing. - if (actual_type.tag.block_entry->selected_type && - actual_type.tag.block_entry->selected_type == expected_type) { - return false; + if (actual_type.tag.block_entry->selected_type) { + if (actual_type.tag.block_entry->selected_type == expected_type) { + return false; + } + if (actual_type.tag.block_entry->selected_type->typespec().base_type() == "vector" && + expected_type.typespec().base_type() == "vector4") { + return false; + } } + { actual_type.tag.block_entry->updated = true; actual_type.tag.block_entry->selected_type = expected_type; diff --git a/game/graphics/opengl_renderer/OpenGLRenderer.cpp b/game/graphics/opengl_renderer/OpenGLRenderer.cpp index f1f17c56ca..1b89970631 100644 --- a/game/graphics/opengl_renderer/OpenGLRenderer.cpp +++ b/game/graphics/opengl_renderer/OpenGLRenderer.cpp @@ -88,6 +88,13 @@ void OpenGLRenderer::init_bucket_renderers_jak2() { m_bucket_renderers.resize((int)BucketId::MAX_BUCKETS); m_bucket_categories.resize((int)BucketId::MAX_BUCKETS, BucketCategory::OTHER); + init_bucket_renderer("tfrag-l0-tfrag", BucketCategory::TFRAG, BucketId::TFRAG_L0_TFRAG, + std::vector{tfrag3::TFragmentTreeKind::NORMAL}, false, 0); + init_bucket_renderer("tfrag-l1-tfrag", BucketCategory::TFRAG, BucketId::TFRAG_L1_TFRAG, + std::vector{tfrag3::TFragmentTreeKind::NORMAL}, false, 0); + init_bucket_renderer("tfrag-t-l0-alpha", BucketCategory::TFRAG, + BucketId::TFRAG_T_L0_ALPHA, + std::vector{tfrag3::TFragmentTreeKind::TRANS}, false, 0); init_bucket_renderer("debug-no-zbuf1", BucketCategory::OTHER, BucketId::DEBUG_NO_ZBUF1, 0x8000); init_bucket_renderer("debug-no-zbuf2", BucketCategory::OTHER, diff --git a/game/graphics/opengl_renderer/background/TFragment.cpp b/game/graphics/opengl_renderer/background/TFragment.cpp index 1a2d815391..3285bf40d1 100644 --- a/game/graphics/opengl_renderer/background/TFragment.cpp +++ b/game/graphics/opengl_renderer/background/TFragment.cpp @@ -46,8 +46,8 @@ void TFragment::render(DmaFollower& dma, // unless we are a child, in which case our parent took this already. if (!m_child_mode) { auto data0 = dma.read_and_advance(); - ASSERT(data0.vif1() == 0); - ASSERT(data0.vif0() == 0); + ASSERT(data0.vifcode1().kind == VifCode::Kind::NOP); + ASSERT(data0.vif0() == 0 || data0.vifcode0().kind == VifCode::Kind::MARK); ASSERT(data0.size_bytes == 0); } @@ -109,7 +109,9 @@ void TFragment::render(DmaFollower& dma, dma.read_and_advance(); } - ASSERT(!level_name.empty()); + if (level_name.empty()) { + return; + } { m_tfrag3.setup_for_level(m_tree_kinds, level_name, render_state); TfragRenderSettings settings; diff --git a/game/graphics/opengl_renderer/buckets.h b/game/graphics/opengl_renderer/buckets.h index f5bb64bf15..63a4bd62a0 100644 --- a/game/graphics/opengl_renderer/buckets.h +++ b/game/graphics/opengl_renderer/buckets.h @@ -80,7 +80,15 @@ enum class BucketId { namespace jak2 { -enum class BucketId { DEBUG_NO_ZBUF1 = 318, DEBUG_NO_ZBUF2 = 325, DEBUG3 = 326, MAX_BUCKETS = 327 }; +enum class BucketId { + TFRAG_L0_TFRAG = 8, + TFRAG_L1_TFRAG = 19, + TFRAG_T_L0_ALPHA = 128, + DEBUG_NO_ZBUF1 = 318, + DEBUG_NO_ZBUF2 = 325, + DEBUG3 = 326, + MAX_BUCKETS = 327 +}; } enum class BucketCategory { diff --git a/game/graphics/opengl_renderer/shaders/tfrag3.vert b/game/graphics/opengl_renderer/shaders/tfrag3.vert index 3cf2104e3e..f4fbb24f74 100644 --- a/game/graphics/opengl_renderer/shaders/tfrag3.vert +++ b/game/graphics/opengl_renderer/shaders/tfrag3.vert @@ -61,7 +61,7 @@ void main() { // hack transformed.xyz *= transformed.w; // scissoring area adjust - transformed.y *= SCISSOR_ADJUST; + transformed.y *= SCISSOR_ADJUST * HEIGHT_SCALE; gl_Position = transformed; // time of day lookup diff --git a/game/graphics/opengl_renderer/shaders/tfrag3_no_tex.vert b/game/graphics/opengl_renderer/shaders/tfrag3_no_tex.vert index 8970445db0..c5639b0fd1 100644 --- a/game/graphics/opengl_renderer/shaders/tfrag3_no_tex.vert +++ b/game/graphics/opengl_renderer/shaders/tfrag3_no_tex.vert @@ -36,7 +36,7 @@ void main() { // hack transformed.xyz *= transformed.w; // scissoring area adjust - transformed.y *= SCISSOR_ADJUST; + transformed.y *= SCISSOR_ADJUST * HEIGHT_SCALE; gl_Position = transformed; // time of day lookup diff --git a/game/kernel/jak2/kmachine.cpp b/game/kernel/jak2/kmachine.cpp index 50f893e50f..babf79f8e8 100644 --- a/game/kernel/jak2/kmachine.cpp +++ b/game/kernel/jak2/kmachine.cpp @@ -473,6 +473,19 @@ u64 kopen(u64 fs, u64 name, u64 mode) { return fs; } +void pc_set_levels(u32 lev_list) { + std::vector levels; + for (int i = 0; i < 6; i++) { + u32 lev = *Ptr(lev_list + i * 4); + std::string ls = Ptr(lev).c()->data(); + if (ls != "none" && ls != "#f" && ls != "") { + levels.push_back(ls); + } + } + + Gfx::set_levels(levels); +} + void InitMachine_PCPort() { // PC Port added functions @@ -482,7 +495,7 @@ void InitMachine_PCPort() { make_function_symbol_from_c("__pc-texture-upload-now", (void*)pc_texture_upload_now); make_function_symbol_from_c("__pc-texture-relocate", (void*)pc_texture_relocate); make_function_symbol_from_c("__pc-get-mips2c", (void*)pc_get_mips2c); - // make_function_symbol_from_c("__pc-set-levels", (void*)pc_set_levels); + make_function_symbol_from_c("__pc-set-levels", (void*)pc_set_levels); // pad stuff make_function_symbol_from_c("pc-pad-get-mapped-button", (void*)Gfx::get_mapped_button); diff --git a/goal_src/jak2/dgos/cta.gd b/goal_src/jak2/dgos/cta.gd new file mode 100644 index 0000000000..49c7555b4b --- /dev/null +++ b/goal_src/jak2/dgos/cta.gd @@ -0,0 +1,13 @@ +("CTA.DGO" + ("ctysluma-part.o" "ctysluma-part") + ("neon-baron-part.o" "neon-baron-part") + ("tpage-974.go" "tpage-974") + ("tpage-973.go" "tpage-973") + ("tpage-1680.go" "tpage-1680") + ("tpage-1021.go" "tpage-1021") + ("tpage-1646.go" "tpage-1646") + ("fort-entry-gate-ag.go" "fort-entry-gate") + ("cty-fruit-stand-ag.go" "cty-fruit-stand") + ("hide-door-a-ag.go" "hide-door-a") + ("ctysluma-vis.go" "ctysluma-vis") + ) \ No newline at end of file diff --git a/goal_src/jak2/dgos/cwi.gd b/goal_src/jak2/dgos/cwi.gd new file mode 100644 index 0000000000..ec4c1147bc --- /dev/null +++ b/goal_src/jak2/dgos/cwi.gd @@ -0,0 +1,68 @@ +("CWI.DGO" + ("nav-graph-h.o" "nav-graph-h") + ("traffic-engine-h.o" "traffic-engine-h") + ("vehicle-h.o" "vehicle-h") + ("citizen-h.o" "citizen-h") + ("height-map-h.o" "height-map-h") + ("ctywide-obs-h.o" "ctywide-obs-h") + ("height-map.o" "height-map") + ("traffic-height-map.o" "traffic-height-map") + ("nav-graph.o" "nav-graph") + ("vehicle-rider.o" "vehicle-rider") + ("vehicle-control.o" "vehicle-control") + ("vehicle-part.o" "vehicle-part") + ("vehicle-effects.o" "vehicle-effects") + ("vehicle.o" "vehicle") + ("vehicle-util.o" "vehicle-util") + ("vehicle-physics.o" "vehicle-physics") + ("vehicle-states.o" "vehicle-states") + ("vehicle-guard.o" "vehicle-guard") + ("transport.o" "transport") + ("bike.o" "bike") + ("car.o" "car") + ("test-bike.o" "test-bike") + ("test-car.o" "test-car") + ("citizen.o" "citizen") + ("civilian.o" "civilian") + ("guard.o" "guard") + ("citizen-norm.o" "citizen-norm") + ("citizen-fat.o" "citizen-fat") + ("citizen-chick.o" "citizen-chick") + ("citizen-enemy.o" "citizen-enemy") + ("metalhead-predator.o" "metalhead-predator") + ("metalhead-grunt.o" "metalhead-grunt") + ("metalhead-flitter.o" "metalhead-flitter") + ("traffic-engine.o" "traffic-engine") + ("trail-graph.o" "trail-graph") + ("trail.o" "trail") + ("traffic-manager.o" "traffic-manager") + ("ctywide-texture.o" "ctywide-texture") + ("ctywide-part.o" "ctywide-part") + ("ctywide-obs.o" "ctywide-obs") + ("ctywide-tasks.o" "ctywide-tasks") + ("ctywide-scenes.o" "ctywide-scenes") + ("ctywide-speech.o" "ctywide-speech") + ("ctyport-obs.o" "ctyport-obs") + ("target-pilot.o" "target-pilot") + ("pilot-states.o" "pilot-states") + ("jak-pilot+0-ag.go" "jak-pilot+0") + ("searchlight.o" "searchlight") + ("tpage-1264.go" "tpage-1264") + ("tpage-1266.go" "tpage-1266") + ("tpage-1265.go" "tpage-1265") + ("tpage-1674.go" "tpage-1674") + ("tpage-1118.go" "tpage-1118") + ("tpage-1657.go" "tpage-1657") + ("baron-statue-ag.go" "baron-statue") + ("cty-guard-turret-ag.go" "cty-guard-turret") + ("vehicle-explosion-ag.go" "vehicle-explosion") + ("barons-ship-lores-ag.go" "barons-ship-lores") + ("propa-ag.go" "propa") + ("vehicle-turret-ag.go" "vehicle-turret") + ("lurker-pipe-lid-ag.go" "lurker-pipe-lid") + ("searchlight-ag.go" "searchlight") + ("burning-bush-ag.go" "burning-bush") + ("stadium-barrier-ag.go" "stadium-barrier") + ("security-wall-ag.go" "security-wall") + ("ctywide-vis.go" "ctywide-vis") + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/debug/memory-usage-h.gc b/goal_src/jak2/engine/debug/memory-usage-h.gc index 29846cca10..0bd8bdc1f6 100644 --- a/goal_src/jak2/engine/debug/memory-usage-h.gc +++ b/goal_src/jak2/engine/debug/memory-usage-h.gc @@ -8,6 +8,14 @@ (defenum mem-usage-id :bitfield #f :type uint32 + (tfragment 1) + (tfragment-base 2) + (tfragment-common 3) + (tfragment-level0 4) + (tfragment-level1 5) + (tfragment-color 6) + (tfragment-debug 7) + (entity 43) (camera 44) diff --git a/goal_src/jak2/engine/draw/draw-node.gc b/goal_src/jak2/engine/draw/draw-node.gc index 6e1db172bf..d5a7b27dd1 100644 --- a/goal_src/jak2/engine/draw/draw-node.gc +++ b/goal_src/jak2/engine/draw/draw-node.gc @@ -5,5 +5,48 @@ ;; name in dgo: draw-node ;; dgos: ENGINE, GAME +;; todo: draw-node-cull + ;; DECOMP BEGINS +(defmethod collect-regions draw-node ((obj draw-node) (arg0 sphere) (arg1 int) (arg2 region-prim-list)) + (dotimes (s2-0 arg1) + (if (spheres-overlap? arg0 (the-as sphere (-> obj bsphere))) + (collect-regions (-> obj child) arg0 (the-as int (-> obj child-count)) arg2) + ) + (&+! obj 32) + ) + 0 + (none) + ) + +(defmethod inspect drawable-inline-array-node ((obj drawable-inline-array-node)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tlength: ~D~%" (-> obj length)) + (format #t "~Tdata[~D]: @ #x~X~%" (-> obj length) (-> obj data)) + (dotimes (s5-0 (-> obj length)) + (format #t "~T [~D] ~A~%" s5-0 (-> obj data s5-0)) + ) + obj + ) + +(defmethod mem-usage drawable-inline-array-node ((obj drawable-inline-array-node) (arg0 memory-usage-block) (arg1 int)) + (set! (-> arg0 length) (max 64 (-> arg0 length))) + (set! (-> arg0 data 63 name) "draw-node") + (+! (-> arg0 data 63 count) (-> obj length)) + (let ((v1-6 (asize-of obj))) + (+! (-> arg0 data 63 used) v1-6) + (+! (-> arg0 data 63 total) (logand -16 (+ v1-6 15))) + ) + obj + ) + +(defmethod asize-of drawable-inline-array-node ((obj drawable-inline-array-node)) + (the-as int (+ (-> drawable-inline-array-node size) (* (+ (-> obj length) -1) 32))) + ) + +(defmethod collect-regions drawable-inline-array-node ((obj drawable-inline-array-node) (arg0 sphere) (arg1 int) (arg2 region-prim-list)) + (collect-regions (the-as draw-node (-> obj data)) arg0 (-> obj length) arg2) + 0 + (none) + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/draw/drawable-h.gc b/goal_src/jak2/engine/draw/drawable-h.gc index c0a5883c9e..8479c6915b 100644 --- a/goal_src/jak2/engine/draw/drawable-h.gc +++ b/goal_src/jak2/engine/draw/drawable-h.gc @@ -17,7 +17,7 @@ (define-extern print-prototype-list (function none)) (define-extern prototype-bucket-recalc-fields (function prototype-bucket prototype-bucket)) (define-extern determine-pause-mode (function int)) - +(define-extern vis-cull (function int symbol)) ;; DECOMP BEGINS diff --git a/goal_src/jak2/engine/draw/drawable.gc b/goal_src/jak2/engine/draw/drawable.gc index 21852d1af2..e3b3aa0a1e 100644 --- a/goal_src/jak2/engine/draw/drawable.gc +++ b/goal_src/jak2/engine/draw/drawable.gc @@ -407,16 +407,27 @@ (with-profiler 'background *profile-background-color* - ;; (init-background) - ;; (execute-connections *background-draw-engine* (-> *display* frames (-> *display* on-screen))) + ;; Run the background renderers! + + ;; first, reset the background-work + (init-background) + + ;; next, collect all levels that are registered with the engine + ;; this will call the drawable system's draw method on the levels which adds all + ;; trees known to the background system to *background-work*. + (execute-connections *background-draw-engine* (-> *display* frames (-> *display* on-screen))) + + ;; execute all background drawing (reset! (-> *perf-stats* data (perf-stat-bucket background))) - ;; (finish-background) + (finish-background) (read! (-> *perf-stats* data (perf-stat-bucket background))) - ; (update-wait-stats (-> *perf-stats* data (perf-stat-bucket background)) - ; (-> *background-work* wait-to-vu0) - ; (the-as uint 0) - ; (the-as uint 0) - ; ) + + ;; update VU stats for background draw. + (update-wait-stats (-> *perf-stats* data (perf-stat-bucket background)) + (-> *background-work* wait-to-vu0) + (the-as uint 0) + (the-as uint 0) + ) ) (end-perf-stat-collection) @@ -922,7 +933,7 @@ ;(-> s4-0 global-buf) ;; post-draw buffer setup - ; (tfrag-vu1-init-buffers) + (tfrag-vu1-init-buffers) ; (tie-vu1-init-buffers) ; (merc-vu1-init-buffers) ; (emerc-vu1-init-buffers) diff --git a/goal_src/jak2/engine/gfx/background/background.gc b/goal_src/jak2/engine/gfx/background/background.gc index c50aab39fb..0e7713ceb2 100644 --- a/goal_src/jak2/engine/gfx/background/background.gc +++ b/goal_src/jak2/engine/gfx/background/background.gc @@ -7,3 +7,547 @@ ;; DECOMP BEGINS +(define *background-work* (new 'global 'background-work)) + +;; identical to Jak 1's VU0 program here. +(define background-vu0-block (new 'static 'vu-function :length 59 :qlength 30)) + +(defun background-upload-vu0 () + ;; (upload-vu0-program background-vu0-block (&-> *background-work* wait-to-vu0)) + 0 + (none) + ) + +(defun init-background () + "Clear the tree list in background-work." + (dotimes (v1-0 8) + (set! (-> *background-work* tfrag-trees v1-0) #f) + (set! (-> *background-work* tfrag-trans-trees v1-0) #f) + (set! (-> *background-work* tfrag-water-trees v1-0) #f) + ) + (set! (-> *background-work* tfrag-tree-count) 0) + (set! (-> *background-work* tfrag-trans-tree-count) 0) + (set! (-> *background-work* tfrag-water-tree-count) 0) + (set! (-> *background-work* shrub-tree-count) 0) + (set! (-> *background-work* tie-tree-count) 0) + (set! (-> *background-work* wait-to-vu0) (the-as uint 0)) + 0 + (none) + ) + +(defconstant VISIBLE_LIST_SCRATCHPAD #x38a0) + +(defun upload-vis-bits ((arg0 level) (arg1 level) (arg2 bsp-header)) + "Upload visibility data to the scratchpad." + (let ((qwc (/ (+ (-> arg2 visible-list-length) 15) 16))) + (let ((lev-vis-bits (the-as (pointer uint128) (-> arg0 vis-bits))) + (all-vis (the-as (pointer uint128) (-> arg2 all-visible-list))) + ;;(spad-vis (the-as (pointer uint128) (+ #x38a0 #x70000000))) + (spad-vis (scratchpad-ptr uint128 :offset VISIBLE_LIST_SCRATCHPAD)) + ) + + (b! (not *artist-flip-visible*) cfg-5 :delay (nop!)) + (nop!) + (nop!) + (label cfg-2) + ;; flip visible is selected. unfortunately this code is wrong and uses a 64-bit xor. + (let ((a3-2 (-> lev-vis-bits 0))) + (set! lev-vis-bits (&-> lev-vis-bits 1)) + (let ((t0-0 (-> all-vis 0))) + (set! all-vis (&-> all-vis 1)) + (nop!) + (nop!) + ;; xor with all visible to flip the bits of the things that exist. + (let ((a3-3 (logxor a3-2 (the-as uint t0-0)))) + (+! qwc -1) + (set! (-> spad-vis 0) a3-3) + ) + ) + ) + (set! spad-vis (&-> spad-vis 1)) + (b! (> qwc 0) cfg-2 :delay (nop!)) + 0 + (b! #t cfg-8 :delay (nop!)) + ;; flip visible isn't selected, just copy to scratchpad. + (nop!) + (label cfg-5) + (nop!) + (nop!) + (label cfg-6) + (let ((a1-2 (-> lev-vis-bits 0))) + (set! lev-vis-bits (&-> lev-vis-bits 1)) + (nop!) + (+! qwc -1) + (set! (-> spad-vis 0) a1-2) + ) + (set! spad-vis (&-> spad-vis 1)) + ) + (b! (> qwc 0) cfg-6 :delay (nop!)) + ) + 0 + (label cfg-8) + (none) + ) + +(defun set-background-regs! ((arg0 level)) + "Set up registers for background drawing. + These are the ones actually used by the background renderers." + (local-vars (v1-1 float) (v1-2 float)) + + ;; set up background regs. These are the same ones used in bsp, but different from "transform" regs. + ;; the "transform" have stuff like hmge/hvdf required to do screen space stuff. This is just geometry. + (let ((v1-0 *math-camera*)) + (with-vf (vf16 vf17 vf18 vf19 vf20 vf21 vf22 vf23 vf24 vf25 vf26 vf27 vf28 vf29 vf30 vf31) + :rw 'write + (cond + ((-> arg0 info use-camera-other) + (.lvf vf16 (&-> v1-0 plane-other 0 quad)) + (.lvf vf17 (&-> v1-0 plane-other 1 quad)) + (.lvf vf18 (&-> v1-0 plane-other 2 quad)) + (.lvf vf19 (&-> v1-0 plane-other 3 quad)) + (.lvf vf20 (&-> v1-0 shrub-mat-other vector 0 quad)) + (.lvf vf21 (&-> v1-0 shrub-mat-other vector 1 quad)) + (.lvf vf22 (&-> v1-0 shrub-mat-other vector 2 quad)) + (.lvf vf23 (&-> v1-0 shrub-mat-other trans quad)) + (.lvf vf24 (&-> v1-0 camera-rot-other vector 0 quad)) + (.lvf vf25 (&-> v1-0 camera-rot-other vector 1 quad)) + (.lvf vf26 (&-> v1-0 camera-rot-other vector 2 quad)) + (.lvf vf27 (&-> v1-0 camera-rot-other trans quad)) + (.lvf vf28 (&-> v1-0 camera-temp-other vector 0 quad)) + (.lvf vf29 (&-> v1-0 camera-temp-other vector 1 quad)) + (.lvf vf30 (&-> v1-0 camera-temp-other vector 2 quad)) + (.lvf vf31 (&-> v1-0 camera-temp-other trans quad)) + (.mov v1-1 vf31) + ) + (else + (.lvf vf16 (&-> v1-0 plane 0 quad)) + (.lvf vf17 (&-> v1-0 plane 1 quad)) + (.lvf vf18 (&-> v1-0 plane 2 quad)) + (.lvf vf19 (&-> v1-0 plane 3 quad)) + (.lvf vf20 (&-> v1-0 shrub-mat vector 0 quad)) + (.lvf vf21 (&-> v1-0 shrub-mat vector 1 quad)) + (.lvf vf22 (&-> v1-0 shrub-mat vector 2 quad)) + (.lvf vf23 (&-> v1-0 shrub-mat trans quad)) + (.lvf vf24 (&-> v1-0 camera-rot vector 0 quad)) + (.lvf vf25 (&-> v1-0 camera-rot vector 1 quad)) + (.lvf vf26 (&-> v1-0 camera-rot vector 2 quad)) + (.lvf vf27 (&-> v1-0 camera-rot trans quad)) + (.lvf vf28 (&-> v1-0 camera-temp vector 0 quad)) + (.lvf vf29 (&-> v1-0 camera-temp vector 1 quad)) + (.lvf vf30 (&-> v1-0 camera-temp vector 2 quad)) + (.lvf vf31 (&-> v1-0 camera-temp trans quad)) + (.mov v1-2 vf31) + ) + ) + ) + ) + + ;; this code would wait for VU0 program upload, then do a vcallms 0 which sets up additional registers, + ;; and stashes stuff in vu0 data memory. + ;; note: vf24-vf27 get messed with here, but after they are stashed in VU0 memory. + + ; sq.xyzw vf24, 4(vi00) | maxw.xyzw vf01, vf00, vf00 + ; sq.xyzw vf25, 5(vi00) | nop + ; sq.xyzw vf26, 6(vi00) | nop + ; sq.xyzw vf27, 7(vi00) | nop + ; sq.xyzw vf16, 0(vi00) | mulz.xyzw vf24, vf01, vf24 + ; sq.xyzw vf17, 1(vi00) | mulz.xyzw vf25, vf01, vf25 + ; sq.xyzw vf18, 2(vi00) | mulz.xyzw vf26, vf01, vf26 + ; sq.xyzw vf19, 3(vi00) | mulz.xyzw vf27, vf01, vf27 + ; sq.xyzw vf24, 12(vi00) | nop + ; sq.xyzw vf25, 13(vi00) | nop + ; sq.xyzw vf26, 14(vi00) | nop + ; sq.xyzw vf27, 15(vi00) | nop + ; sq.xyzw vf28, 8(vi00) | nop + ; sq.xyzw vf29, 9(vi00) | nop + ; sq.xyzw vf30, 10(vi00) | nop + ; sq.xyzw vf31, 11(vi00) | nop :e + ; iaddiu vi02, vi00, 0xf0 | nop + + #| + (let ((v1-3 (the-as object #x10008000)) + (a0-4 (the-as (pointer integer) (&-> *background-work* wait-to-vu0))) + ) + (b! (zero? (logand (-> (the-as (pointer int32) v1-3) 0) 256)) cfg-5 :delay (nop!)) + (let ((a1-2 (-> (the-as (pointer int32) a0-4) 0))) + (nop!) + (let ((a2-0 (-> (the-as (pointer int32) v1-3) 0))) + (nop!) + (let ((a2-1 (logand a2-0 256)) + (a1-3 (+ a1-2 1)) + ) + (b! (nonzero? a2-1) cfg-4 :delay (set! (-> (the-as (pointer uint32) a0-4) 0) (the-as uint a1-3))) + ) + ) + ) + ) + (label cfg-5) + 0 + (.vcallms 0) + |# + 0 + (none) + ) + +(defun set-tie-quard-planes! ((arg0 level)) + "Update guard planes for tie. The use-camera-other stuff can be used to effectively 'move' a level, + so the camera guard planes need to be set accordingly." + (cond + ((-> arg0 info use-camera-other) + (set! (-> *instance-tie-work* guard-plane 0 quad) (-> *math-camera* guard-plane-other 0 quad)) + (set! (-> *instance-tie-work* guard-plane 1 quad) (-> *math-camera* guard-plane-other 1 quad)) + (set! (-> *instance-tie-work* guard-plane 2 quad) (-> *math-camera* guard-plane-other 2 quad)) + (set! (-> *instance-tie-work* guard-plane 3 quad) (-> *math-camera* guard-plane-other 3 quad)) + ) + (else + (set! (-> *instance-tie-work* guard-plane 0 quad) (-> *math-camera* guard-plane 0 quad)) + (set! (-> *instance-tie-work* guard-plane 1 quad) (-> *math-camera* guard-plane 1 quad)) + (set! (-> *instance-tie-work* guard-plane 2 quad) (-> *math-camera* guard-plane 2 quad)) + (set! (-> *instance-tie-work* guard-plane 3 quad) (-> *math-camera* guard-plane 3 quad)) + ) + ) + (none) + ) + +(defun set-shrub-quard-planes! ((arg0 level)) + "Update guard planes for shrub. The use-camera-other stuff can be used to effectively 'move' a level, + so the camera guard planes need to be set accordingly." + (cond + ((-> arg0 info use-camera-other) + (set! (-> *instance-shrub-work* guard-plane 0 quad) (-> *math-camera* guard-plane-other 0 quad)) + (set! (-> *instance-shrub-work* guard-plane 1 quad) (-> *math-camera* guard-plane-other 1 quad)) + (set! (-> *instance-shrub-work* guard-plane 2 quad) (-> *math-camera* guard-plane-other 2 quad)) + (set! (-> *instance-shrub-work* guard-plane 3 quad) (-> *math-camera* guard-plane-other 3 quad)) + ) + (else + (set! (-> *instance-shrub-work* guard-plane 0 quad) (-> *math-camera* guard-plane 0 quad)) + (set! (-> *instance-shrub-work* guard-plane 1 quad) (-> *math-camera* guard-plane 1 quad)) + (set! (-> *instance-shrub-work* guard-plane 2 quad) (-> *math-camera* guard-plane 2 quad)) + (set! (-> *instance-shrub-work* guard-plane 3 quad) (-> *math-camera* guard-plane 3 quad)) + ) + ) + (none) + ) + +(defun finish-background () + "Main function for drawing the background (wind, shrub, tie, tfrag)" + (if (-> *blit-displays-work* menu-mode) + (return #f) + ) + + + ;; update wind! + (when (not (paused?)) + (flush-cache 0) + (with-profiler 'wind *profile-particles-color* + (dotimes (gp-1 (-> *level* length)) + (let ((v1-28 (-> *level* level gp-1))) + (when (= (-> v1-28 status) 'active) + (-> v1-28 bsp unk-data 5) + (if (nonzero? (-> v1-28 bsp wind-array-length)) + (when (nonzero? level-update-wind) (level-update-wind *wind-work*)) ;; added nonzero check + ) + ) + ) + ) + ) + ) + + ;; start VU0 upload for background. + (background-upload-vu0) + (dotimes (v1-51 (-> *level* length)) + (let ((a0-23 (-> *level* level v1-51))) + (when (= (-> a0-23 status) 'active) + (let ((a0-24 (-> a0-23 bsp))) + (when (nonzero? (-> a0-24 tfrag-masks)) + (dotimes (a1-9 (-> a0-24 tfrag-masks length)) + (set! (-> a0-24 tfrag-closest a1-9) 4095996000.0) + ) + ) + (when (nonzero? (-> a0-24 shrub-masks)) + (dotimes (a1-14 (-> a0-24 shrub-masks length)) + (set! (-> a0-24 shrub-closest a1-14) 4095996000.0) + ) + ) + (when (nonzero? (-> a0-24 alpha-masks)) + (dotimes (a1-19 (-> a0-24 alpha-masks length)) + (set! (-> a0-24 alpha-closest a1-19) 4095996000.0) + ) + ) + (when (nonzero? (-> a0-24 water-masks)) + (dotimes (a1-24 (-> a0-24 water-masks length)) + (set! (-> a0-24 water-closest a1-24) 4095996000.0) + ) + ) + ) + ) + ) + ) + + + ; (when (nonzero? (-> *background-work* shrub-tree-count)) + ; (with-profiler 'instance-shrubbery *profile-instance-shrubbery-color* + ; (dotimes (gp-4 (-> *background-work* shrub-tree-count)) + ; (set! *draw-index* (-> *background-work* shrub-levels gp-4 draw-index)) + ; (flush-cache 0) + ; (let ((s5-3 (-> *background-work* shrub-trees gp-4)) + ; (s4-3 (-> *background-work* shrub-levels gp-4)) + ; ) + ; (if (nonzero? (-> s5-3 colors-added)) + ; (time-of-day-interp-colors + ; (-> *instance-shrub-work* colors) + ; (the-as uint (-> s5-3 colors-added)) + ; (-> s4-3 mood-context) + ; ) + ; ) + ; (set-background-regs! s4-3) + ; (set-shrub-quard-planes! s4-3) + ; (draw-drawable-tree-instance-shrub s5-3 s4-3) + ; ) + ; ) + ; ) + ; ) + + (let ((gp-6 (the-as level #f))) + (when (or (nonzero? (-> *background-work* tfrag-tree-count)) + (nonzero? (-> *background-work* tfrag-trans-tree-count)) + (nonzero? (-> *background-work* tfrag-water-tree-count)) + ) + (let ((s5-7 (max (max (-> *background-work* tfrag-tree-count) (-> *background-work* tfrag-trans-tree-count)) + (-> *background-work* tfrag-water-tree-count) + ) + ) + (s4-5 (the-as time-of-day-palette #f)) + ) + + (with-profiler 'tfrag *profile-tfrag-color* + (dotimes (s3-3 s5-7) + (let ((s2-1 (-> *background-work* tfrag-trees s3-3))) + (when s2-1 + (let ((s1-1 (-> *background-work* tfrag-levels s3-3))) + (let ((a2-23 (-> s1-1 bsp)) + (s0-1 (-> s2-1 time-of-day-pal)) + ) + (upload-vis-bits s1-1 gp-6 a2-23) + (when (not (or (zero? s0-1) (= s4-5 s0-1))) + (flush-cache 0) + ;; (time-of-day-interp-colors-scratch (the-as (pointer rgba) (+ 6144 #x70000000)) s0-1 (-> s1-1 mood-context)) + (set! s4-5 s0-1) + ) + ) + (set! *draw-index* (-> s1-1 draw-index)) + (set! (-> *tfrag-work* min-dist z) 4095996000.0) + (set-background-regs! s1-1) + ) + (draw-drawable-tree-tfrag s2-1) + (set! (-> *level* draw-level *draw-index* closest-object) (-> *tfrag-work* min-dist z)) + ) + ) + (let ((s2-2 (-> *background-work* tfrag-trans-trees s3-3))) + (when s2-2 + (let ((s1-2 (-> *background-work* tfrag-trans-levels s3-3))) + (let ((a2-25 (-> s1-2 bsp)) + (s0-2 (-> s2-2 time-of-day-pal)) + ) + (upload-vis-bits s1-2 gp-6 a2-25) + (when (not (or (zero? s0-2) (= s4-5 s0-2))) + (flush-cache 0) + ;; (time-of-day-interp-colors-scratch (the-as (pointer rgba) (+ 6144 #x70000000)) s0-2 (-> s1-2 mood-context)) + (set! s4-5 s0-2) + ) + ) + (set! *draw-index* (-> s1-2 draw-index)) + (set! (-> *tfrag-work* min-dist z) 4095996000.0) + (set-background-regs! s1-2) + ) + (draw-drawable-tree-tfrag-trans s2-2) + (set! (-> *level* draw-level *draw-index* closest-object-array 3) (-> *tfrag-work* min-dist z)) + ) + ) + (let ((s2-3 (-> *background-work* tfrag-water-trees s3-3))) + (when s2-3 + (let ((s1-3 (-> *background-work* tfrag-water-levels s3-3))) + (let ((a2-27 (-> s1-3 bsp)) + (s0-3 (-> s2-3 time-of-day-pal)) + ) + (upload-vis-bits s1-3 gp-6 a2-27) + (when (not (or (zero? s0-3) (= s4-5 s0-3))) + (flush-cache 0) + ;; (time-of-day-interp-colors-scratch (the-as (pointer rgba) (+ 6144 #x70000000)) s0-3 (-> s1-3 mood-context)) + (set! s4-5 s0-3) + ) + ) + (set! *draw-index* (-> s1-3 draw-index)) + (set! (-> *tfrag-work* min-dist z) 4095996000.0) + (set-background-regs! s1-3) + ) + (draw-drawable-tree-tfrag-water s2-3) + (set! (-> *level* draw-level *draw-index* closest-object-array 4) (-> *tfrag-work* min-dist z)) + ) + ) + ) + ) + ) + ) + + ; (when (nonzero? (-> *background-work* tie-tree-count)) + ; (set! (-> *instance-tie-work* tod-env-color quad) (-> *time-of-day-context* current-env-color quad)) + ; (with-profiler 'instance-tie *profile-instance-tie-color* + ; (dotimes (s5-10 (-> *background-work* tie-tree-count)) + ; (let ((s4-8 (-> *background-work* tie-levels s5-10))) + ; (let ((a2-29 (-> s4-8 bsp))) + ; (when (!= s4-8 gp-6) + ; (set! (-> *instance-tie-work* min-dist x) 4095996000.0) + ; (upload-vis-bits s4-8 gp-6 a2-29) + ; (set! gp-6 s4-8) + ; ) + ; ) + ; (set! *draw-index* (-> s4-8 draw-index)) + ; (set! (-> *prototype-tie-work* mood) (-> s4-8 mood-context)) + ; (set-background-regs! s4-8) + ; (set-tie-quard-planes! s4-8) + ; (tie-scissor-make-perspective-matrix + ; (-> *instance-tie-work* tie-scissor-perspective-matrix) + ; (if (-> s4-8 info use-camera-other) + ; (-> *math-camera* camera-temp-other) + ; (-> *math-camera* camera-temp) + ; ) + ; ) + ; (draw-drawable-tree-instance-tie (-> *background-work* tie-trees s5-10) s4-8) + ; ) + ; (set! (-> *background-work* tie-generic s5-10) (the-as basic (-> *prototype-tie-work* generic-next))) + ; (set! (-> *background-work* tie-generic-trans s5-10) + ; (the-as basic (-> *prototype-tie-work* generic-trans-next)) + ; ) + ; ) + ; ) + ; ) + ) + + (dotimes (v1-282 (-> *level* length)) + (let ((a1-46 (-> *level* level v1-282))) + (when (= (-> a1-46 status) 'active) + (let ((a0-120 (-> a1-46 bsp))) + (when (nonzero? (-> a0-120 tfrag-masks)) + (let ((a2-34 (-> a1-46 texture-mask))) + (dotimes (a3-4 (-> a0-120 tfrag-masks length)) + (let ((f0-12 (* (-> (the-as (pointer float) (&+ (-> a0-120 tfrag-closest) (* a3-4 4))) 0) + (-> *math-camera* fov-correction-factor) + ) + ) + ) + (when (!= f0-12 4095996000.0) + (let ((t0-8 (-> a0-120 tfrag-masks data a3-4))) + (dotimes (t1-2 3) + (when (or (= t1-2 2) (>= f0-12 (-> t0-8 data t1-2 dist))) + (dotimes (t2-5 3) + (logior! + (-> (&-> a2-34 0 mask data t2-5) 0) + (-> (the-as (pointer int32) (+ (* t2-5 4) (the-as int t0-8) (* t1-2 16))) 0) + ) + ) + (goto cfg-158) + ) + ) + ) + ) + ) + (label cfg-158) + ) + ) + ) + (when (nonzero? (-> a0-120 shrub-masks)) + (let ((a2-39 (-> a1-46 texture-mask 2))) + (dotimes (a3-5 (-> a0-120 shrub-masks length)) + (let ((f0-14 (* (-> (the-as (pointer float) (&+ (-> a0-120 shrub-closest) (* a3-5 4))) 0) + (-> *math-camera* fov-correction-factor) + ) + ) + ) + (when (!= f0-14 4095996000.0) + (let ((t0-24 (-> a0-120 shrub-masks data a3-5))) + (dotimes (t1-5 3) + (when (or (= t1-5 2) (>= f0-14 (-> t0-24 data t1-5 dist))) + (dotimes (t2-11 3) + (logior! + (-> a2-39 mask data t2-11) + (-> (the-as (pointer int32) (+ (* t2-11 4) (the-as int t0-24) (* t1-5 16))) 0) + ) + ) + (goto cfg-178) + ) + ) + ) + ) + ) + (label cfg-178) + ) + ) + ) + (when (nonzero? (-> a0-120 alpha-masks)) + (let ((a2-44 (-> a1-46 texture-mask 3))) + (dotimes (a3-6 (-> a0-120 alpha-masks length)) + (let ((f0-16 (* (-> (the-as (pointer float) (&+ (-> a0-120 alpha-closest) (* a3-6 4))) 0) + (-> *math-camera* fov-correction-factor) + ) + ) + ) + (when (!= f0-16 4095996000.0) + (let ((t0-40 (-> a0-120 alpha-masks data a3-6))) + (dotimes (t1-8 3) + (when (or (= t1-8 2) (>= f0-16 (-> t0-40 data t1-8 dist))) + (dotimes (t2-17 3) + (logior! + (-> a2-44 mask data t2-17) + (-> (the-as (pointer int32) (+ (* t2-17 4) (the-as int t0-40) (* t1-8 16))) 0) + ) + ) + (goto cfg-198) + ) + ) + ) + ) + ) + (label cfg-198) + ) + ) + ) + (when (nonzero? (-> a0-120 water-masks)) + (let ((a1-47 (-> a1-46 texture-mask 4))) + (dotimes (a2-49 (-> a0-120 water-masks length)) + (let ((f0-18 (* (-> (the-as (pointer float) (&+ (-> a0-120 water-closest) (* a2-49 4))) 0) + (-> *math-camera* fov-correction-factor) + ) + ) + ) + (when (!= f0-18 4095996000.0) + (let ((a3-15 (-> a0-120 water-masks data a2-49))) + (dotimes (t0-50 3) + (when (or (= t0-50 2) (>= f0-18 (-> a3-15 data t0-50 dist))) + (dotimes (t1-14 3) + (logior! + (-> a1-47 mask data t1-14) + (-> (the-as (pointer int32) (+ (* t1-14 4) (the-as int a3-15) (* t0-50 16))) 0) + ) + ) + (goto cfg-218) + ) + ) + ) + ) + ) + (label cfg-218) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + + + + diff --git a/goal_src/jak2/engine/gfx/background/prototype-h.gc b/goal_src/jak2/engine/gfx/background/prototype-h.gc index 6e9c5e957d..3abc8a5ec6 100644 --- a/goal_src/jak2/engine/gfx/background/prototype-h.gc +++ b/goal_src/jak2/engine/gfx/background/prototype-h.gc @@ -11,6 +11,7 @@ :bitfield #t :type uint16 (disable 0) + ;; (use-envmap 1) maybe (tpage-alpha 2) (vanish 3) (tpage-water 7) diff --git a/goal_src/jak2/engine/gfx/background/wind-h.gc b/goal_src/jak2/engine/gfx/background/wind-h.gc index 344a148e2d..a4424aeba3 100644 --- a/goal_src/jak2/engine/gfx/background/wind-h.gc +++ b/goal_src/jak2/engine/gfx/background/wind-h.gc @@ -63,3 +63,6 @@ :size-assert #x3000 :flag-assert #x900003000 ) + +;; DECOMP ENDS +(define-extern level-update-wind (function wind-work none)) diff --git a/goal_src/jak2/engine/gfx/hw/display-h.gc b/goal_src/jak2/engine/gfx/hw/display-h.gc index 433f1649f6..3371f3c428 100644 --- a/goal_src/jak2/engine/gfx/hw/display-h.gc +++ b/goal_src/jak2/engine/gfx/hw/display-h.gc @@ -94,8 +94,8 @@ (defconstant DEFAULT_ALL_RENDERERS (vu1-renderer-mask - rn3 rn4 rn5 rn6 rn7 rn8 rn9 rn10 rn11 rn12 merc emerc rn15 rn16 - rn17 rn18 rn19 rn20 rn21 rn22 rn23 rn24 rn25 rn26 rn27 rn28 rn29 + rn3 rn4 rn5 tfrag rn7 rn8 rn9 rn10 rn11 rn12 merc emerc rn15 rn16 + rn17 rn18 tfrag-trans rn20 rn21 rn22 rn23 tfrag-water rn25 rn26 rn27 rn28 rn29 rn30 rn31 rn32 rn34 ) ) diff --git a/goal_src/jak2/engine/gfx/merc/merc.gc b/goal_src/jak2/engine/gfx/merc/merc.gc index 7f48eede4c..a81ecbd256 100644 --- a/goal_src/jak2/engine/gfx/merc/merc.gc +++ b/goal_src/jak2/engine/gfx/merc/merc.gc @@ -74,7 +74,7 @@ (.por a3-3 a3-2 t0-0) (let ((f0-1 (fmax f0-0 f1-0))) (set! (-> a2-3 mask quad) a3-3) - (set! (-> a2-3 mask w) (the-as int f0-1)) + (set! (-> a2-3 dist) f0-1) ) ) ) diff --git a/goal_src/jak2/engine/gfx/shrub/shrubbery.gc b/goal_src/jak2/engine/gfx/shrub/shrubbery.gc index 80c3cd37b9..e569135e9a 100644 --- a/goal_src/jak2/engine/gfx/shrub/shrubbery.gc +++ b/goal_src/jak2/engine/gfx/shrub/shrubbery.gc @@ -183,12 +183,12 @@ (dotimes (a1-0 3) (set! (-> (the-as (pointer int32) (+ (+ (* a0-5 16) (* a1-0 4)) (the-as int *texture-masks*)))) (logior (-> (the-as (pointer int32) (+ (* a1-0 4) (the-as int *texture-masks*) (* a0-5 16))) 0) - (-> (the-as (inline-array texture-masks) (+ (* a1-0 4) (the-as int v1-3) (* a0-5 16))) 1 data 0 mask w) + (-> (the-as (pointer int32) (+ (* a1-0 4) (the-as int v1-3) (* a0-5 16))) 15) ) ) ) - (set! (-> *texture-masks* data a0-5 mask w) - (the-as int (fmax (-> *texture-masks* data a0-5 dist) (-> v1-3 masks data a0-5 dist))) + (set! (-> *texture-masks* data a0-5 dist) + (fmax (-> *texture-masks* data a0-5 dist) (-> v1-3 masks data a0-5 dist)) ) ) ) @@ -472,7 +472,7 @@ (let ((dma-buff (-> *display* frames (-> *display* on-screen) global-buf))) (when (nonzero? (-> tree length)) (let ((dma-start (-> *display* frames (-> *display* on-screen) global-buf base))) - + (reset! (-> *perf-stats* data (perf-stat-bucket inst-shrub))) (draw-inline-array-instance-shrub dma-buff @@ -481,11 +481,11 @@ proto-array-data ) (read! (-> *perf-stats* data (perf-stat-bucket inst-shrub))) - + (reset! (-> *perf-stats* data (perf-stat-bucket proto-shrub))) (draw-prototype-inline-array-shrub proto-array-len proto-array-data) (read! (-> *perf-stats* data (perf-stat-bucket proto-shrub))) - + (let ((v1-33 *dma-mem-usage*)) (when (nonzero? v1-33) (set! (-> v1-33 length) (max 28 (-> v1-33 length))) diff --git a/goal_src/jak2/engine/gfx/texture/texture.gc b/goal_src/jak2/engine/gfx/texture/texture.gc index 247c01f690..2d9a7fd199 100644 --- a/goal_src/jak2/engine/gfx/texture/texture.gc +++ b/goal_src/jak2/engine/gfx/texture/texture.gc @@ -2594,13 +2594,10 @@ (def-mips2c adgif-shader<-texture-with-update! (function adgif-shader texture adgif-shader)) (defun hack-texture ((arg0 texture)) - "Some sort of uv-dist hack for hi-res mode." + "Some sort of uv hack for hi-res mode" (set! (-> arg0 uv-dist) 1000000.0) - (set! (-> arg0 masks data 0 mask w) (the-as int (+ 40960000.0 (-> arg0 masks data 0 dist)))) - (let ((f0-4 (+ 40960000.0 (-> arg0 masks data 1 dist)))) - (set! (-> arg0 masks data 1 mask w) (the-as int f0-4)) - f0-4 - ) + (set! (-> arg0 masks data 0 dist) (+ 40960000.0 (-> arg0 masks data 0 dist))) + (set! (-> arg0 masks data 1 dist) (+ 40960000.0 (-> arg0 masks data 1 dist))) ) (define-extern level-remap-texture (function texture-id texture-id)) diff --git a/goal_src/jak2/engine/gfx/tfrag/tfrag-h.gc b/goal_src/jak2/engine/gfx/tfrag/tfrag-h.gc index aae599f154..15804ed5b2 100644 --- a/goal_src/jak2/engine/gfx/tfrag/tfrag-h.gc +++ b/goal_src/jak2/engine/gfx/tfrag/tfrag-h.gc @@ -9,6 +9,8 @@ (declare-type tfrag-work structure) (define-extern *tfrag-work* tfrag-work) +(define-extern *pc-tfrag-draw-level* level) ;; added + ;; DECOMP BEGINS (deftype tfragment-stats (structure) @@ -48,6 +50,7 @@ (dma-base uint32 :offset 36) (dma-level-1 uint32 :offset 40) (dma-qwc uint8 4 :offset 44) + (dma-u32 uint32 :offset 44) (shader (inline-array adgif-shader) :offset 48) (num-shaders uint8 :offset 52) (num-base-colors uint8 :offset 53) @@ -247,3 +250,7 @@ :size-assert #x37fc :flag-assert #x9000037fc ) + +(define-extern draw-drawable-tree-tfrag (function drawable-tree-tfrag none)) +(define-extern draw-drawable-tree-tfrag-trans (function drawable-tree-tfrag none)) +(define-extern draw-drawable-tree-tfrag-water (function drawable-tree-tfrag none)) \ No newline at end of file diff --git a/goal_src/jak2/engine/gfx/tfrag/tfrag-methods.gc b/goal_src/jak2/engine/gfx/tfrag/tfrag-methods.gc index 71486fc851..8696084462 100644 --- a/goal_src/jak2/engine/gfx/tfrag/tfrag-methods.gc +++ b/goal_src/jak2/engine/gfx/tfrag/tfrag-methods.gc @@ -7,3 +7,849 @@ ;; DECOMP BEGINS +(defun edge-debug-lines ((arg0 (array vector-array))) + (when (nonzero? arg0) + (dotimes (s5-0 (-> arg0 length)) + (when (logtest? *display-strip-lines* (ash 1 s5-0)) + (let ((s4-0 (-> arg0 s5-0))) + (dotimes (s3-0 (/ (-> s4-0 length) 2)) + (add-debug-line + #t + (bucket-id debug-no-zbuf1) + (-> s4-0 data (* s3-0 2)) + (-> s4-0 data (+ (* s3-0 2) 1)) + (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + #f + (the-as rgba -1) + ) + ) + ) + ) + ) + ) + (none) + ) + +(defun draw-drawable-tree-tfrag ((arg0 drawable-tree-tfrag)) + (local-vars (sv-16 (pointer uint8))) + (when (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask tfrag)) + (let ((s5-0 (+ (-> arg0 length) -1))) + (when (nonzero? s5-0) + ;; TODO draw node cull (not really needed because c++ does it already) + ; (dotimes (s4-0 s5-0) + ; (let* ((v1-8 (-> arg0 arrays s4-0)) + ; (a0-4 (-> arg0 arrays (+ s4-0 1))) + ; (a1-1 (/ (-> (the-as drawable-inline-array-node v1-8) data 0 id) 8)) + ; (a0-6 (/ (-> (the-as drawable-inline-array-node a0-4) data 0 id) 8)) + ; (a1-3 (+ a1-1 #x38a0 #x70000000)) + ; (a0-8 (+ a0-6 #x38a0 #x70000000)) + ; ) + ; (draw-node-cull + ; (the-as pointer a0-8) + ; (the-as pointer a1-3) + ; (the-as (inline-array draw-node) (&+ v1-8 32)) + ; (-> v1-8 length) + ; ) + ; ) + ; ) + ) + (let* ((v1-13 (the-as drawable-inline-array-tfrag (-> arg0 arrays s5-0))) + (s4-1 (-> v1-13 data)) + (s3-0 (-> v1-13 length)) + ) + (set! sv-16 (&-> (scratchpad-object terrain-context) work background vis-list (/ (-> s4-1 0 id) 8))) + (let ((s5-1 (-> *display* frames (-> *display* on-screen) global-buf base))) + (let* ((s1-0 (-> *display* frames (-> *display* on-screen) global-buf)) + (s2-0 (-> s1-0 base)) + ) + (set! (-> *tfrag-work* wait-to-spr) (the-as uint 0)) + (set! (-> *tfrag-work* wait-from-spr) (the-as uint 0)) + (set! (-> *tfrag-work* texture-dists) (the-as uint (-> *level* draw-level *draw-index* bsp tfrag-closest))) + (set! (-> *tfrag-work* last-call) (the-as uint 0)) + ;(draw-inline-array-tfrag (the-as pointer sv-16) s4-1 s3-0 s1-0) + (set! (-> *level* draw-level *draw-index* tfrag-last-calls 0) (the-as int (-> *tfrag-work* last-call))) + (update-wait-stats + (-> *perf-stats* data 42) + (the-as uint 0) + (-> *tfrag-work* wait-to-spr) + (-> *tfrag-work* wait-from-spr) + ) + (let ((a3-3 (-> s1-0 base))) + (let ((v1-46 (the-as dma-packet (-> s1-0 base)))) + (set! (-> v1-46 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> v1-46 vif0) (new 'static 'vif-tag)) + (set! (-> v1-46 vif1) (new 'static 'vif-tag)) + (set! (-> s1-0 base) (the-as pointer (&+ v1-46 16))) + ) + (let ((t9-3 dma-bucket-insert-tag) + (a0-22 (-> *display* frames (-> *display* on-screen) bucket-group)) + (v1-53 *draw-index*) + ) + (t9-3 + a0-22 + (cond + ((zero? v1-53) + (bucket-id tfrag-l0-tfrag) + ) + ((= v1-53 1) + (bucket-id tfrag-l1-tfrag) + ) + ((= v1-53 2) + (bucket-id tfrag-l2-tfrag) + ) + ((= v1-53 3) + (bucket-id tfrag-l3-tfrag) + ) + ((= v1-53 4) + (bucket-id tfrag-l4-tfrag) + ) + (else + (bucket-id tfrag-l5-tfrag) + ) + ) + s2-0 + (the-as (pointer dma-tag) a3-3) + ) + ) + ) + ) + ; (let* ((s1-1 (-> *display* frames (-> *display* on-screen) global-buf)) + ; (s2-1 (-> s1-1 base)) + ; ) + ; (set! (-> *tfrag-work* near-wait-to-spr) (the-as uint 0)) + ; (set! (-> *tfrag-work* near-wait-from-spr) (the-as uint 0)) + ; (set! (-> *tfrag-work* last-call) (the-as uint 0)) + ; (draw-inline-array-tfrag-scissor (the-as pointer sv-16) s4-1 s3-0 s1-1) + ; (set! (-> *level* draw-level *draw-index* tfrag-last-calls 1) (the-as int (-> *tfrag-work* last-call))) + ; (update-wait-stats + ; (-> *perf-stats* data 43) + ; (the-as uint 0) + ; (-> *tfrag-work* near-wait-to-spr) + ; (-> *tfrag-work* near-wait-from-spr) + ; ) + ; (let ((a3-6 (-> s1-1 base))) + ; (let ((v1-70 (the-as dma-packet (-> s1-1 base)))) + ; (set! (-> v1-70 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + ; (set! (-> v1-70 vif0) (new 'static 'vif-tag)) + ; (set! (-> v1-70 vif1) (new 'static 'vif-tag)) + ; (set! (-> s1-1 base) (the-as pointer (&+ v1-70 16))) + ; ) + ; (let ((t9-6 dma-bucket-insert-tag) + ; (a0-32 (-> *display* frames (-> *display* on-screen) bucket-group)) + ; (v1-77 *draw-index*) + ; ) + ; (t9-6 + ; a0-32 + ; (cond + ; ((zero? v1-77) + ; (bucket-id tfrag-s-l0-tfrag) + ; ) + ; ((= v1-77 1) + ; (bucket-id tfrag-s-l1-tfrag) + ; ) + ; ((= v1-77 2) + ; (bucket-id tfrag-s-l2-tfrag) + ; ) + ; ((= v1-77 3) + ; (bucket-id tfrag-s-l3-tfrag) + ; ) + ; ((= v1-77 4) + ; (bucket-id tfrag-s-l4-tfrag) + ; ) + ; (else + ; (bucket-id tfrag-s-l5-tfrag) + ; ) + ; ) + ; s2-1 + ; (the-as (pointer dma-tag) a3-6) + ; ) + ; ) + ; ) + ; ) + (let ((v1-78 *dma-mem-usage*)) + (when (nonzero? v1-78) + (set! (-> v1-78 length) (max 2 (-> v1-78 length))) + (set! (-> v1-78 data 1 name) "tfragment") + (+! (-> v1-78 data 1 count) 1) + (+! (-> v1-78 data 1 used) + (&- (-> *display* frames (-> *display* on-screen) global-buf base) (the-as uint s5-1)) + ) + (set! (-> v1-78 data 1 total) (-> v1-78 data 1 used)) + ) + ) + ) + ) + ) + ) + (none) + ) + +(defun draw-drawable-tree-tfrag-trans ((arg0 drawable-tree-tfrag)) + (local-vars sv-16 (pointer uint8)) + (when (logtest? (vu1-renderer-mask tfrag-trans) (-> *display* vu1-enable-user)) + (let ((s5-0 (+ (-> arg0 length) -1))) + ;; TODO draw node cull (not really needed because c++ does it already) + ; (when (nonzero? s5-0) + ; (dotimes (s4-0 s5-0) + ; (let* ((v1-7 (-> arg0 arrays s4-0)) + ; (a0-6 (-> arg0 arrays (+ s4-0 1))) + ; (a1-1 (/ (-> (the-as drawable-inline-array-node v1-7) data 0 id) 8)) + ; (a0-8 (/ (-> (the-as drawable-inline-array-node a0-6) data 0 id) 8)) + ; (a1-3 (+ a1-1 #x38a0 #x70000000)) + ; (a0-10 (+ a0-8 #x38a0 #x70000000)) + ; ) + ; (draw-node-cull + ; (the-as pointer a0-10) + ; (the-as pointer a1-3) + ; (the-as (inline-array draw-node) (&+ v1-7 32)) + ; (-> v1-7 length) + ; ) + ; ) + ; ) + ; ) + (let* ((v1-13 (the-as drawable-inline-array-tfrag (-> arg0 arrays s5-0))) + (s5-1 (-> v1-13 data)) + (s4-1 (-> v1-13 length)) + ) + (set! sv-16 (&-> (scratchpad-object terrain-context) work background vis-list (/ (-> s5-1 0 id) 8))) + (let* ((s2-0 (-> *display* frames (-> *display* on-screen) global-buf)) + (s3-0 (-> s2-0 base)) + ) + (set! (-> *tfrag-work* wait-to-spr) (the-as uint 0)) + (set! (-> *tfrag-work* wait-from-spr) (the-as uint 0)) + (set! (-> *tfrag-work* texture-dists) (the-as uint (-> *level* draw-level *draw-index* bsp alpha-closest))) + (set! (-> *tfrag-work* last-call) (the-as uint 0)) + ; (draw-inline-array-tfrag (the-as pointer sv-16) s5-1 s4-1 s2-0) + (set! (-> *level* draw-level *draw-index* tfrag-last-calls 2) (the-as int (-> *tfrag-work* last-call))) + (update-wait-stats + (-> *perf-stats* data 42) + (the-as uint 0) + (-> *tfrag-work* wait-to-spr) + (-> *tfrag-work* wait-from-spr) + ) + (let ((a3-3 (-> s2-0 base))) + (let ((v1-39 (the-as dma-packet (-> s2-0 base)))) + (set! (-> v1-39 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> v1-39 vif0) (new 'static 'vif-tag)) + (set! (-> v1-39 vif1) (new 'static 'vif-tag)) + (set! (-> s2-0 base) (the-as pointer (&+ v1-39 16))) + ) + (let ((t9-3 dma-bucket-insert-tag) + (a0-23 (-> *display* frames (-> *display* on-screen) bucket-group)) + (v1-46 *draw-index*) + ) + (t9-3 + a0-23 + (cond + ((zero? v1-46) + (bucket-id tfrag-t-l0-alpha) + ) + ((= v1-46 1) + (bucket-id tfrag-t-l1-alpha) + ) + ((= v1-46 2) + (bucket-id tfrag-t-l2-alpha) + ) + ((= v1-46 3) + (bucket-id tfrag-t-l3-alpha) + ) + ((= v1-46 4) + (bucket-id tfrag-t-l4-alpha) + ) + (else + (bucket-id tfrag-t-l5-alpha) + ) + ) + s3-0 + (the-as (pointer dma-tag) a3-3) + ) + ) + ) + ) + ; (let* ((s2-1 (-> *display* frames (-> *display* on-screen) global-buf)) + ; (s3-1 (-> s2-1 base)) + ; ) + ; (set! (-> *tfrag-work* near-wait-to-spr) (the-as uint 0)) + ; (set! (-> *tfrag-work* near-wait-from-spr) (the-as uint 0)) + ; (set! (-> *tfrag-work* last-call) (the-as uint 0)) + ; (draw-inline-array-tfrag-scissor (the-as pointer sv-16) s5-1 s4-1 s2-1) + ; (set! (-> *level* draw-level *draw-index* tfrag-last-calls 3) (the-as int (-> *tfrag-work* last-call))) + ; (update-wait-stats + ; (-> *perf-stats* data 43) + ; (the-as uint 0) + ; (-> *tfrag-work* near-wait-to-spr) + ; (-> *tfrag-work* near-wait-from-spr) + ; ) + ; (let ((a3-6 (-> s2-1 base))) + ; (let ((v1-63 (the-as dma-packet (-> s2-1 base)))) + ; (set! (-> v1-63 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + ; (set! (-> v1-63 vif0) (new 'static 'vif-tag)) + ; (set! (-> v1-63 vif1) (new 'static 'vif-tag)) + ; (set! (-> s2-1 base) (the-as pointer (&+ v1-63 16))) + ; ) + ; (let ((t9-6 dma-bucket-insert-tag) + ; (a0-33 (-> *display* frames (-> *display* on-screen) bucket-group)) + ; (v1-70 *draw-index*) + ; ) + ; (t9-6 + ; a0-33 + ; (cond + ; ((zero? v1-70) + ; (bucket-id tfrag-st-l0-alpha) + ; ) + ; ((= v1-70 1) + ; (bucket-id tfrag-st-l1-alpha) + ; ) + ; ((= v1-70 2) + ; (bucket-id tfrag-st-l2-alpha) + ; ) + ; ((= v1-70 3) + ; (bucket-id tfrag-st-l3-alpha) + ; ) + ; ((= v1-70 4) + ; (bucket-id tfrag-st-l4-alpha) + ; ) + ; (else + ; (bucket-id tfrag-st-l5-alpha) + ; ) + ; ) + ; s3-1 + ; (the-as (pointer dma-tag) a3-6) + ; ) + ; ) + ; ) + ; ) + ) + ) + ) + (none) + ) + +(defun draw-drawable-tree-tfrag-water ((arg0 drawable-tree-tfrag)) + (local-vars (sv-16 (pointer uint8))) + (when (logtest? (vu1-renderer-mask tfrag-water) (-> *display* vu1-enable-user)) + (let ((s5-0 (+ (-> arg0 length) -1))) + ;; TODO draw node cull (not really needed because c++ does it already) + ; (when (nonzero? s5-0) + ; (dotimes (s4-0 s5-0) + ; (let* ((v1-7 (-> arg0 arrays s4-0)) + ; (a0-6 (-> arg0 arrays (+ s4-0 1))) + ; (a1-1 (/ (-> (the-as drawable-inline-array-node v1-7) data 0 id) 8)) + ; (a0-8 (/ (-> (the-as drawable-inline-array-node a0-6) data 0 id) 8)) + ; (a1-3 (+ a1-1 #x38a0 #x70000000)) + ; (a0-10 (+ a0-8 #x38a0 #x70000000)) + ; ) + ; (draw-node-cull + ; (the-as pointer a0-10) + ; (the-as pointer a1-3) + ; (the-as (inline-array draw-node) (&+ v1-7 32)) + ; (-> v1-7 length) + ; ) + ; ) + ; ) + ; ) + (let* ((v1-13 (the-as drawable-inline-array-tfrag (-> arg0 arrays s5-0))) + (s5-1 (-> v1-13 data)) + (s4-1 (-> v1-13 length)) + ) + (set! sv-16 (&-> (scratchpad-object terrain-context) work background vis-list (/ (-> s5-1 0 id) 8))) + (let* ((s2-0 (-> *display* frames (-> *display* on-screen) global-buf)) + (s3-0 (-> s2-0 base)) + ) + (set! (-> *tfrag-work* wait-to-spr) (the-as uint 0)) + (set! (-> *tfrag-work* wait-from-spr) (the-as uint 0)) + (set! (-> *tfrag-work* texture-dists) (the-as uint (-> *level* draw-level *draw-index* bsp water-closest))) + (set! (-> *tfrag-work* last-call) (the-as uint 0)) + ; (draw-inline-array-tfrag (the-as pointer sv-16) s5-1 s4-1 s2-0) + (set! (-> *level* draw-level *draw-index* tfrag-last-calls 4) (the-as int (-> *tfrag-work* last-call))) + (update-wait-stats + (-> *perf-stats* data 42) + (the-as uint 0) + (-> *tfrag-work* wait-to-spr) + (-> *tfrag-work* wait-from-spr) + ) + (let ((a3-3 (-> s2-0 base))) + (let ((v1-39 (the-as dma-packet (-> s2-0 base)))) + (set! (-> v1-39 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> v1-39 vif0) (new 'static 'vif-tag)) + (set! (-> v1-39 vif1) (new 'static 'vif-tag)) + (set! (-> s2-0 base) (the-as pointer (&+ v1-39 16))) + ) + (let ((t9-3 dma-bucket-insert-tag) + (a0-23 (-> *display* frames (-> *display* on-screen) bucket-group)) + (v1-46 *draw-index*) + ) + (t9-3 + a0-23 + (cond + ((zero? v1-46) + (bucket-id tfrag-w-l0-water) + ) + ((= v1-46 1) + (bucket-id tfrag-w-l1-water) + ) + ((= v1-46 2) + (bucket-id tfrag-w-l2-water) + ) + ((= v1-46 3) + (bucket-id tfrag-w-l3-water) + ) + ((= v1-46 4) + (bucket-id tfrag-w-l4-water) + ) + (else + (bucket-id tfrag-w-l5-water) + ) + ) + s3-0 + (the-as (pointer dma-tag) a3-3) + ) + ) + ) + ) + ; (let* ((s2-1 (-> *display* frames (-> *display* on-screen) global-buf)) + ; (s3-1 (-> s2-1 base)) + ; ) + ; (set! (-> *tfrag-work* near-wait-to-spr) (the-as uint 0)) + ; (set! (-> *tfrag-work* near-wait-from-spr) (the-as uint 0)) + ; (set! (-> *tfrag-work* last-call) (the-as uint 0)) + ; (draw-inline-array-tfrag-scissor (the-as pointer sv-16) s5-1 s4-1 s2-1) + ; (set! (-> *level* draw-level *draw-index* tfrag-last-calls 5) (the-as int (-> *tfrag-work* last-call))) + ; (update-wait-stats + ; (-> *perf-stats* data 43) + ; (the-as uint 0) + ; (-> *tfrag-work* near-wait-to-spr) + ; (-> *tfrag-work* near-wait-from-spr) + ; ) + ; (let ((a3-6 (-> s2-1 base))) + ; (let ((v1-63 (the-as dma-packet (-> s2-1 base)))) + ; (set! (-> v1-63 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + ; (set! (-> v1-63 vif0) (new 'static 'vif-tag)) + ; (set! (-> v1-63 vif1) (new 'static 'vif-tag)) + ; (set! (-> s2-1 base) (the-as pointer (&+ v1-63 16))) + ; ) + ; (let ((t9-6 dma-bucket-insert-tag) + ; (a0-33 (-> *display* frames (-> *display* on-screen) bucket-group)) + ; (v1-70 *draw-index*) + ; ) + ; (t9-6 + ; a0-33 + ; (cond + ; ((zero? v1-70) + ; (bucket-id tfrag-ws-l0-water) + ; ) + ; ((= v1-70 1) + ; (bucket-id tfrag-ws-l1-water) + ; ) + ; ((= v1-70 2) + ; (bucket-id tfrag-ws-l2-water) + ; ) + ; ((= v1-70 3) + ; (bucket-id tfrag-ws-l3-water) + ; ) + ; ((= v1-70 4) + ; (bucket-id tfrag-ws-l4-water) + ; ) + ; (else + ; (bucket-id tfrag-ws-l5-water) + ; ) + ; ) + ; s3-1 + ; (the-as (pointer dma-tag) a3-6) + ; ) + ; ) + ; ) + ; ) + ) + ) + ) + (none) + ) + +(defun tfrag-vu1-init-buf ((arg0 bucket-id) (arg1 gs-test) (arg2 int) (arg3 uint) (arg4 symbol)) + (let ((s4-0 (-> *display* frames (-> *display* on-screen) bucket-group arg0))) + (when (!= s4-0 (-> s4-0 last)) + (let* ((s3-0 (-> *display* frames (-> *display* on-screen) global-buf)) + (s2-1 (-> s3-0 base)) + ) + (tfrag-init-buffer s3-0 arg1 arg2 arg4) + (let ((v1-12 (the-as object (-> s3-0 base)))) + (set! (-> (the-as dma-packet v1-12) dma) (new 'static 'dma-tag :id (dma-tag-id next) :addr (-> s4-0 next))) + (set! (-> (the-as dma-packet v1-12) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet v1-12) vif1) (new 'static 'vif-tag)) + (set! (-> s3-0 base) (the-as pointer (&+ (the-as dma-packet v1-12) 16))) + ) + (set! (-> s4-0 next) (the-as uint s2-1)) + ) + ) + ) + (let ((s5-1 (-> *display* frames (-> *display* on-screen) bucket-group arg0))) + (when (!= s5-1 (-> s5-1 last)) + (let* ((s3-1 (-> *display* frames (-> *display* on-screen) global-buf)) + (s4-1 (-> s3-1 base)) + ) + (tfrag-end-buffer s3-1 (the-as int arg3)) + (let ((v0-3 (-> s3-1 base))) + (let ((v1-26 (the-as object (-> s3-1 base)))) + (set! (-> (the-as dma-packet v1-26) dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> (the-as dma-packet v1-26) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet v1-26) vif1) (new 'static 'vif-tag)) + (set! (-> s3-1 base) (&+ (the-as pointer v1-26) 16)) + ) + (set! (-> (the-as (pointer int32) (-> s5-1 last)) 1) (the-as int s4-1)) + (set! (-> s5-1 last) (the-as (pointer dma-tag) v0-3)) + ) + ) + ) + ) + (none) + ) + +(defun tfrag-scissor-vu1-init-buf ((arg0 bucket-id) (arg1 gs-test) (arg2 int) (arg3 uint) (arg4 symbol)) + ;; (break!) ;; no scissor + (none) + ) + +(deftype tfrag-init-data (structure) + ((tfrag-bucket bucket-id :offset-assert 0) + (tfrag-scissor-bucket bucket-id :offset-assert 4) + (tfrag-trans-bucket bucket-id :offset-assert 8) + (tfrag-scissor-trans-bucket bucket-id :offset-assert 12) + (tfrag-water-bucket bucket-id :offset-assert 16) + (tfrag-water-scissor-bucket bucket-id :offset-assert 20) + ) + :method-count-assert 9 + :size-assert #x18 + :flag-assert #x900000018 + ) + +(define *tfrag-init-table* (new 'static 'inline-array tfrag-init-data 6 + (new 'static 'tfrag-init-data + :tfrag-bucket (bucket-id tfrag-l0-tfrag) + :tfrag-scissor-bucket (bucket-id tfrag-s-l0-tfrag) + :tfrag-trans-bucket (bucket-id tfrag-t-l0-alpha) + :tfrag-scissor-trans-bucket (bucket-id tfrag-st-l0-alpha) + :tfrag-water-bucket (bucket-id tfrag-w-l0-water) + :tfrag-water-scissor-bucket (bucket-id tfrag-ws-l0-water) + ) + (new 'static 'tfrag-init-data + :tfrag-bucket (bucket-id tfrag-l1-tfrag) + :tfrag-scissor-bucket (bucket-id tfrag-s-l1-tfrag) + :tfrag-trans-bucket (bucket-id tfrag-t-l1-alpha) + :tfrag-scissor-trans-bucket (bucket-id tfrag-st-l1-alpha) + :tfrag-water-bucket (bucket-id tfrag-w-l1-water) + :tfrag-water-scissor-bucket (bucket-id tfrag-ws-l1-water) + ) + (new 'static 'tfrag-init-data + :tfrag-bucket (bucket-id tfrag-l2-tfrag) + :tfrag-scissor-bucket (bucket-id tfrag-s-l2-tfrag) + :tfrag-trans-bucket (bucket-id tfrag-t-l2-alpha) + :tfrag-scissor-trans-bucket (bucket-id tfrag-st-l2-alpha) + :tfrag-water-bucket (bucket-id tfrag-w-l2-water) + :tfrag-water-scissor-bucket (bucket-id tfrag-ws-l2-water) + ) + (new 'static 'tfrag-init-data + :tfrag-bucket (bucket-id tfrag-l3-tfrag) + :tfrag-scissor-bucket (bucket-id tfrag-s-l3-tfrag) + :tfrag-trans-bucket (bucket-id tfrag-t-l3-alpha) + :tfrag-scissor-trans-bucket (bucket-id tfrag-st-l3-alpha) + :tfrag-water-bucket (bucket-id tfrag-w-l3-water) + :tfrag-water-scissor-bucket (bucket-id tfrag-ws-l3-water) + ) + (new 'static 'tfrag-init-data + :tfrag-bucket (bucket-id tfrag-l4-tfrag) + :tfrag-scissor-bucket (bucket-id tfrag-s-l4-tfrag) + :tfrag-trans-bucket (bucket-id tfrag-t-l4-alpha) + :tfrag-scissor-trans-bucket (bucket-id tfrag-st-l4-alpha) + :tfrag-water-bucket (bucket-id tfrag-w-l4-water) + :tfrag-water-scissor-bucket (bucket-id tfrag-ws-l4-water) + ) + (new 'static 'tfrag-init-data + :tfrag-bucket (bucket-id tfrag-l5-tfrag) + :tfrag-scissor-bucket (bucket-id tfrag-s-l5-tfrag) + :tfrag-trans-bucket (bucket-id tfrag-t-l5-alpha) + :tfrag-scissor-trans-bucket (bucket-id tfrag-st-l5-alpha) + :tfrag-water-bucket (bucket-id tfrag-w-l5-water) + :tfrag-water-scissor-bucket (bucket-id tfrag-ws-l5-water) + ) + ) + ) + +(define *pc-tfrag-draw-level* (the level #f)) + +(defun tfrag-vu1-init-buffers () + (dotimes (gp-0 6) + (let ((s5-0 (-> *level* draw-level gp-0)) + (s4-0 (-> *tfrag-init-table* gp-0)) + ) + (set! *pc-tfrag-draw-level* s5-0) + (when s5-0 + (let ((s3-0 (-> s5-0 tfrag-gs-test))) + (tfrag-vu1-init-buf + (-> s4-0 tfrag-bucket) + s3-0 + 0 + (-> s5-0 tfrag-last-calls-u32 0) + (-> s5-0 info use-camera-other) + ) + (tfrag-scissor-vu1-init-buf + (-> s4-0 tfrag-scissor-bucket) + s3-0 + 0 + (-> s5-0 tfrag-last-calls-u32 1) + (-> s5-0 info use-camera-other) + ) + ) + (tfrag-vu1-init-buf + (-> s4-0 tfrag-trans-bucket) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x26 + :afail #x1 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 1 + (-> s5-0 tfrag-last-calls-u32 2) + (-> s5-0 info use-camera-other) + ) + (tfrag-scissor-vu1-init-buf + (-> s4-0 tfrag-scissor-trans-bucket) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x26 + :afail #x1 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 1 + (-> s5-0 tfrag-last-calls-u32 3) + (-> s5-0 info use-camera-other) + ) + (tfrag-vu1-init-buf + (-> s4-0 tfrag-water-bucket) + (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest greater-equal)) + 1 + (-> s5-0 tfrag-last-calls-u32 4) + (-> s5-0 info use-camera-other) + ) + (tfrag-scissor-vu1-init-buf + (-> s4-0 tfrag-water-scissor-bucket) + (new 'static 'gs-test :ate #x1 :afail #x1 :zte #x1 :ztst (gs-ztest greater-equal)) + 1 + (-> s5-0 tfrag-last-calls-u32 5) + (-> s5-0 info use-camera-other) + ) + ) + ) + ) + (none) + ) + +(defmethod draw drawable-tree-tfrag ((obj drawable-tree-tfrag) (arg0 drawable-tree-tfrag) (arg1 display-frame)) + (let ((v1-1 (-> *background-work* tfrag-tree-count)) + (a1-4 (-> *level* draw-level *draw-index*)) + ) + (set! (-> *background-work* tfrag-trees v1-1) obj) + (set! (-> *background-work* tfrag-levels v1-1) a1-4) + ) + (+! (-> *background-work* tfrag-tree-count) 1) + 0 + (none) + ) + +(defmethod draw drawable-tree-tfrag-trans ((obj drawable-tree-tfrag-trans) (arg0 drawable-tree-tfrag-trans) (arg1 display-frame)) + (let ((v1-1 (-> *background-work* tfrag-trans-tree-count)) + (a1-4 (-> *level* draw-level *draw-index*)) + ) + (set! (-> *background-work* tfrag-trans-trees v1-1) obj) + (set! (-> *background-work* tfrag-trans-levels v1-1) a1-4) + ) + (+! (-> *background-work* tfrag-trans-tree-count) 1) + 0 + (none) + ) + +(defmethod draw drawable-tree-tfrag-water ((obj drawable-tree-tfrag-water) (arg0 drawable-tree-tfrag-water) (arg1 display-frame)) + (let ((v1-1 (-> *background-work* tfrag-water-tree-count)) + (a1-4 (-> *level* draw-level *draw-index*)) + ) + (set! (-> *background-work* tfrag-water-trees v1-1) obj) + (set! (-> *background-work* tfrag-water-levels v1-1) a1-4) + ) + (+! (-> *background-work* tfrag-water-tree-count) 1) + 0 + (none) + ) + +(defmethod collect-stats tfragment ((obj tfragment)) + (stats-tfrag-asm obj) + 0 + (none) + ) + +(defmethod collect-stats drawable-tree-tfrag ((obj drawable-tree-tfrag)) + (when (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask tfrag)) + (set! (-> *tfrag-work* vu1-enable-tfrag) + (the-as int (logand (-> *display* vu1-enable-user) (vu1-renderer-mask tfrag))) + ) + (set! (-> *tfrag-work* vu1-enable-tfrag-scissor) + (the-as int (logand (-> *display* vu1-enable-user) (vu1-renderer-mask tfrag))) + ) + (set! (-> *tfrag-work* tr-stat-tfrag) (-> *terrain-stats* tfrag)) + (set! (-> *tfrag-work* tr-stat-tfrag-scissor) (-> *terrain-stats* tfrag-scissor)) + (let ((v1-15 (-> *tfrag-work* frag-dists quad))) + (set! (-> *tfrag-work* frag-dists quad) v1-15) + ) + (dotimes (s5-0 (-> obj length)) + (collect-stats (-> obj arrays s5-0)) + ) + ) + 0 + (none) + ) + +(defmethod collect-stats drawable-tree-tfrag-trans ((obj drawable-tree-tfrag-trans)) + (when (logtest? (vu1-renderer-mask tfrag-trans) (-> *display* vu1-enable-user)) + (set! (-> *tfrag-work* vu1-enable-tfrag) + (the-as int (logand (vu1-renderer-mask tfrag-trans) (-> *display* vu1-enable-user))) + ) + (set! (-> *tfrag-work* vu1-enable-tfrag-scissor) + (the-as int (logand (vu1-renderer-mask tfrag-trans) (-> *display* vu1-enable-user))) + ) + (set! (-> *tfrag-work* tr-stat-tfrag) (-> *terrain-stats* tfrag-trans)) + (set! (-> *tfrag-work* tr-stat-tfrag-scissor) (-> *terrain-stats* tfrag-scissor-trans)) + (let ((v1-12 (-> *tfrag-work* frag-dists quad))) + (set! (-> *tfrag-work* frag-dists quad) v1-12) + ) + (dotimes (s5-0 (-> obj length)) + (collect-stats (-> obj arrays s5-0)) + ) + ) + 0 + (none) + ) + +(defmethod collect-stats drawable-tree-tfrag-water ((obj drawable-tree-tfrag-water)) + (when (logtest? (vu1-renderer-mask tfrag-water) (-> *display* vu1-enable-user)) + (set! (-> *tfrag-work* vu1-enable-tfrag) + (the-as int (logand (vu1-renderer-mask tfrag-water) (-> *display* vu1-enable-user))) + ) + (set! (-> *tfrag-work* vu1-enable-tfrag-scissor) + (the-as int (logand (vu1-renderer-mask tfrag-water) (-> *display* vu1-enable-user))) + ) + (set! (-> *tfrag-work* tr-stat-tfrag) (-> *terrain-stats* tfrag-water)) + (set! (-> *tfrag-work* tr-stat-tfrag-scissor) (-> *terrain-stats* tfrag-scissor-water)) + (let ((v1-12 (-> *tfrag-work* frag-dists quad))) + (set! (-> *tfrag-work* frag-dists quad) v1-12) + ) + (dotimes (s5-0 (-> obj length)) + (collect-stats (-> obj arrays s5-0)) + ) + ) + 0 + (none) + ) + +(defmethod collect-stats drawable-inline-array-tfrag ((obj drawable-inline-array-tfrag)) + (when (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask tfrag)) + (dotimes (s5-0 (-> obj length)) + (let ((s4-0 (-> obj data s5-0))) + (if (vis-cull (-> s4-0 id)) + (collect-stats s4-0) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod collect-stats drawable-inline-array-tfrag-trans ((obj drawable-inline-array-tfrag-trans)) + (when (logtest? (vu1-renderer-mask tfrag-trans) (-> *display* vu1-enable-user)) + (dotimes (s5-0 (-> obj length)) + (let ((s4-0 (-> obj data s5-0))) + (if (vis-cull (-> s4-0 id)) + (collect-stats s4-0) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod collect-stats drawable-inline-array-tfrag-water ((obj drawable-inline-array-tfrag-water)) + (when (logtest? (vu1-renderer-mask tfrag-water) (-> *display* vu1-enable-user)) + (dotimes (s5-0 (-> obj length)) + (let ((s4-0 (-> obj data s5-0))) + (if (vis-cull (-> s4-0 id)) + (collect-stats s4-0) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod debug-draw drawable-tree-tfrag ((obj drawable-tree-tfrag) (arg0 drawable) (arg1 display-frame)) + (when (logtest? (-> *display* vu1-enable-user) (vu1-renderer-mask tfrag)) + (dotimes (s4-0 (-> obj length)) + (let ((a1-1 (-> obj arrays s4-0))) + (debug-draw a1-1 a1-1 arg1) + ) + ) + ) + 0 + (none) + ) + +(defmethod debug-draw drawable-tree-tfrag-trans ((obj drawable-tree-tfrag-trans) (arg0 drawable) (arg1 display-frame)) + (when (logtest? (vu1-renderer-mask tfrag-trans) (-> *display* vu1-enable-user)) + (dotimes (s4-0 (-> obj length)) + (let ((a1-1 (-> obj arrays s4-0))) + (debug-draw a1-1 a1-1 arg1) + ) + ) + ) + 0 + (none) + ) + +(defmethod debug-draw drawable-tree-tfrag-water ((obj drawable-tree-tfrag-water) (arg0 drawable) (arg1 display-frame)) + (when (logtest? (vu1-renderer-mask tfrag-water) (-> *display* vu1-enable-user)) + (dotimes (s4-0 (-> obj length)) + (let ((a1-1 (-> obj arrays s4-0))) + (debug-draw a1-1 a1-1 arg1) + ) + ) + ) + 0 + (none) + ) + +(defmethod debug-draw drawable-inline-array-tfrag ((obj drawable-inline-array-tfrag) (arg0 drawable) (arg1 display-frame)) + (dotimes (s4-0 (-> obj length)) + (let ((s3-0 (-> obj data s4-0))) + (if (vis-cull (-> s3-0 id)) + (debug-draw s3-0 s3-0 arg1) + ) + ) + ) + 0 + (none) + ) + +(defmethod debug-draw tfragment ((obj tfragment) (arg0 drawable) (arg1 display-frame)) + (-> arg1 global-buf) + (edge-debug-lines (-> obj debug-data debug-lines)) + 0 + (none) + ) + + + + diff --git a/goal_src/jak2/engine/gfx/tfrag/tfrag-near.gc b/goal_src/jak2/engine/gfx/tfrag/tfrag-near.gc index badd36d09e..27c1f2355b 100644 --- a/goal_src/jak2/engine/gfx/tfrag/tfrag-near.gc +++ b/goal_src/jak2/engine/gfx/tfrag/tfrag-near.gc @@ -7,3 +7,71 @@ ;; DECOMP BEGINS +(define tnear-vu1-block (new 'static 'vu-function :length #x38b :qlength #x1c6)) + +(defun-debug tfrag-details ((arg0 tfragment)) + (format 0 "id = ~d~%" (-> arg0 id)) + (format 0 "common:~%") + (let ((s5-0 (-> arg0 dma-qwc 0)) + (s4-0 (-> arg0 dma-common)) + ) + (format 0 "qwc = ~d, ref = ~x~%" s5-0 s4-0) + (disasm-vif-tag (the-as (pointer vif-tag) s4-0) (the-as int (* s5-0 4)) (the-as symbol 0) #t) + ) + (format 0 "base:~%") + (let ((s5-1 (-> arg0 dma-qwc 1)) + (s4-1 (-> arg0 dma-base)) + ) + (format 0 "qwc = ~d, ref = ~x~%" s5-1 s4-1) + (disasm-vif-tag (the-as (pointer vif-tag) s4-1) (the-as int (* s5-1 4)) (the-as symbol 0) #t) + ) + (format 0 "level-0:~%") + (let ((s5-2 (-> arg0 dma-qwc 3)) + (s4-2 (-> arg0 dma-u32)) ;; bug: this isn't actually the level0 chain... see jak 1. + ) + (format 0 "qwc = ~d, ref = ~x~%" s5-2 s4-2) + (disasm-vif-tag (the-as (pointer vif-tag) s4-2) (the-as int (* s5-2 4)) (the-as symbol 0) #t) + ) + (format 0 "level-1:~%") + (let ((s5-3 (-> arg0 dma-qwc 2)) + (gp-1 (-> arg0 dma-level-1)) + ) + (format 0 "qwc = ~d, ref = ~x~%" s5-3 gp-1) + (disasm-vif-tag (the-as (pointer vif-tag) gp-1) (the-as int (* s5-3 4)) (the-as symbol 0) #t) + ) + (none) + ) + +(defun-debug clip-restore () + "Restore the camera to some place. Same as jak 1, so likely not a meaningful location." + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) 92648.22) + (set! (-> a0-0 y) 238025.03) + (set! (-> a0-0 z) 199836.31) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) -0.9283) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) 0.3716) + (set! (-> a1-0 vector 0 w) 0.0) + (set! (-> a1-0 vector 1 x) -0.2257) + (set! (-> a1-0 vector 1 y) 0.7945) + (set! (-> a1-0 vector 1 z) -0.5637) + (set! (-> a1-0 vector 1 w) 0.0) + (set! (-> a1-0 vector 2 x) -0.2952) + (set! (-> a1-0 vector 2 y) -0.6072) + (set! (-> a1-0 vector 2 z) -0.7375) + (set! (-> a1-0 vector 2 w) 0.0) + (set! (-> a1-0 trans x) 0.0) + (set! (-> a1-0 trans y) 0.0) + (set! (-> a1-0 trans z) 0.0) + (set! (-> a1-0 trans w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + (none) + ) + + + + diff --git a/goal_src/jak2/engine/gfx/tfrag/tfrag-work.gc b/goal_src/jak2/engine/gfx/tfrag/tfrag-work.gc index a3a1e39f75..5b13e5f5ae 100644 --- a/goal_src/jak2/engine/gfx/tfrag/tfrag-work.gc +++ b/goal_src/jak2/engine/gfx/tfrag/tfrag-work.gc @@ -7,3 +7,37 @@ ;; DECOMP BEGINS +(define *tfrag-work* (new 'static 'tfrag-work + :base-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id ref)) + :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + :level-0-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id ref)) + :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + :common-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id ref)) + :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + :level-1-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id ref)) + :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + :color-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id cnt)) + :vif0 (new 'static 'vif-tag :imm #x102 :cmd (vif-cmd stcycl)) + :vif1 (new 'static 'vif-tag :imm #xc000 :cmd (vif-cmd unpack-v4-8)) + ) + :max-fragment #xffff + ) + ) + +(set! (-> *tfrag-work* color-ptr x) (+ 6144 (the-as int *fake-scratchpad-data*))) +(set! (-> *tfrag-work* color-ptr y) (+ 6144 (the-as int *fake-scratchpad-data*))) +(set! (-> *tfrag-work* color-ptr z) (+ 6144 (the-as int *fake-scratchpad-data*))) +(set! (-> *tfrag-work* color-ptr w) (+ 6144 (the-as int *fake-scratchpad-data*))) + + + + diff --git a/goal_src/jak2/engine/gfx/tfrag/tfrag.gc b/goal_src/jak2/engine/gfx/tfrag/tfrag.gc index b70d8d7d78..d4f76c6a29 100644 --- a/goal_src/jak2/engine/gfx/tfrag/tfrag.gc +++ b/goal_src/jak2/engine/gfx/tfrag/tfrag.gc @@ -7,3 +7,507 @@ ;; DECOMP BEGINS +(defmethod login tfragment ((obj tfragment)) + "Initialize a tfragment by linking the textures in adgif shaders" + (when (nonzero? *texture-masks-array*) + (dotimes (s5-0 (the-as int (-> obj num-shaders))) + (let ((v1-3 (adgif-shader-login-no-remap (-> obj shader s5-0))) + (a0-7 (-> *texture-masks-array* data (-> obj texture-masks-index))) + ) + (when v1-3 + (dotimes (a1-3 3) + (dotimes (a2-0 3) + (set! (-> (the-as (pointer int32) (+ (+ (* a1-3 16) (* a2-0 4)) (the-as int a0-7)))) + (logior (-> (the-as (pointer int32) (+ (* a2-0 4) (the-as int a0-7) (* a1-3 16))) 0) + (-> (the-as texture (+ (* a2-0 4) (the-as int v1-3) (* a1-3 16))) masks data 0 mask x) + ) + ) + ) + (set! (-> a0-7 data a1-3 dist) (fmax (-> a0-7 data a1-3 dist) (-> v1-3 masks data a1-3 dist))) + ) + ) + ) + ) + ) + obj + ) + +(defmethod mem-usage tfragment ((obj tfragment) (arg0 memory-usage-block) (arg1 int)) + "Compute the memory usage of a tfragment" + (when (logtest? arg1 2) + (+! (-> arg0 data 19 count) 1) + (let ((v1-6 (+ (-> obj num-base-colors) (-> obj num-level0-colors) (-> obj num-level1-colors)))) + (+! (-> arg0 data 19 used) v1-6) + (+! (-> arg0 data 19 total) (logand -4 (+ v1-6 3))) + ) + (set! obj obj) + (goto cfg-16) + ) + (let ((s4-0 1)) + (set! (-> arg0 length) (max (-> arg0 length) (+ s4-0 8))) + (set! (-> arg0 data s4-0 name) (symbol->string 'tfragment)) + (+! (-> arg0 data s4-0 count) 1) + (let ((v1-22 (asize-of obj))) + (+! (-> arg0 data s4-0 used) v1-22) + (+! (-> arg0 data s4-0 total) (logand -16 (+ v1-22 15))) + ) + (set! (-> arg0 data (+ s4-0 1) name) "tfragment-base") + (+! (-> arg0 data (+ s4-0 1) count) 1) + (let ((v1-33 (* (-> obj dma-qwc 0) 16))) + (+! (-> arg0 data (+ s4-0 1) used) v1-33) + (+! (-> arg0 data (+ s4-0 1) total) v1-33) + ) + (set! (-> arg0 data (+ s4-0 2) name) "tfragment-common") + (+! (-> arg0 data (+ s4-0 2) count) 1) + (let ((v1-43 (* (- (-> obj dma-qwc 1) (-> obj dma-qwc 0)) 16))) + (+! (-> arg0 data (+ s4-0 2) used) v1-43) + (+! (-> arg0 data (+ s4-0 2) total) v1-43) + ) + (set! (-> arg0 data (+ s4-0 3) name) "tfragment-level0") + (when (nonzero? (-> obj num-level0-colors)) + (+! (-> arg0 data (+ s4-0 3) count) 1) + (let ((v1-55 (* (- (-> obj dma-qwc 2) (-> obj dma-qwc 0)) 16))) + (+! (-> arg0 data (+ s4-0 3) used) v1-55) + (+! (-> arg0 data (+ s4-0 3) total) v1-55) + ) + ) + (set! (-> arg0 data (+ s4-0 4) name) "tfragment-level1") + (when (not (or (= (-> obj dma-level-1) (-> obj dma-common)) + (= (-> obj dma-level-1) (-> obj dma-base)) + (zero? (-> obj num-level1-colors)) + ) + ) + (+! (-> arg0 data (+ s4-0 4) count) 1) + (let ((v1-70 + (* (- (-> obj dma-qwc 3) + (- (/ (the-as int (- (-> obj dma-level-1) (the-as uint (-> obj dma-common)))) 16) (-> obj dma-qwc 0)) + ) + 16 + ) + ) + ) + (+! (-> arg0 data (+ s4-0 4) used) v1-70) + (+! (-> arg0 data (+ s4-0 4) total) v1-70) + ) + ) + (set! (-> arg0 data (+ s4-0 5) name) "tfragment-color") + (+! (-> arg0 data (+ s4-0 5) count) 1) + (let ((v1-79 + (if (logtest? arg1 1) + 0 + (the-as int (* (+ (-> obj num-base-colors) (-> obj num-level0-colors) (-> obj num-level1-colors)) 2)) + ) + ) + ) + (+! (-> arg0 data (+ s4-0 5) used) v1-79) + (+! (-> arg0 data (+ s4-0 5) total) (logand -16 (+ v1-79 15))) + ) + (set! (-> arg0 data (+ s4-0 6) name) "tfragment-debug") + ) + (label cfg-16) + obj + ) + +(defmethod inspect drawable-inline-array-tfrag ((obj drawable-inline-array-tfrag)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tlength: ~D~%" (-> obj length)) + (format #t "~Tdata[~D]: @ #x~X~%" (-> obj length) (-> obj data)) + (dotimes (s5-0 (-> obj length)) + (format #t "~T [~D] ~A~%" s5-0 (-> obj data s5-0)) + ) + obj + ) + +(defmethod login drawable-inline-array-tfrag ((obj drawable-inline-array-tfrag)) + (set! *texture-masks-array* (-> *level* level *level-index* bsp tfrag-masks)) + (dotimes (s5-0 (-> obj length)) + (login (-> obj data s5-0)) + ) + obj + ) + +(defmethod login drawable-inline-array-tfrag-trans ((obj drawable-inline-array-tfrag-trans)) + (set! *texture-masks-array* (-> *level* level *level-index* bsp alpha-masks)) + (dotimes (s5-0 (-> obj length)) + (login (-> obj data s5-0)) + ) + obj + ) + +(defmethod login drawable-inline-array-tfrag-water ((obj drawable-inline-array-tfrag-water)) + (set! *texture-masks-array* (-> *level* level *level-index* bsp water-masks)) + (dotimes (s5-0 (-> obj length)) + (login (-> obj data s5-0)) + ) + obj + ) + +(defmethod mem-usage drawable-inline-array-tfrag ((obj drawable-inline-array-tfrag) (arg0 memory-usage-block) (arg1 int)) + (set! (-> arg0 length) (max 1 (-> arg0 length))) + (set! (-> arg0 data 0 name) (symbol->string 'drawable-group)) + (+! (-> arg0 data 0 count) 1) + (let ((v1-7 32)) + (+! (-> arg0 data 0 used) v1-7) + (+! (-> arg0 data 0 total) (logand -16 (+ v1-7 15))) + ) + (dotimes (s3-0 (-> obj length)) + (mem-usage (-> obj data s3-0) arg0 arg1) + ) + obj + ) + +;; definition for method 8 of type drawable-tree-tfrag +(defmethod mem-usage drawable-tree-tfrag ((obj drawable-tree-tfrag) (arg0 memory-usage-block) (arg1 int)) + (set! (-> arg0 length) (max 1 (-> arg0 length))) + (set! (-> arg0 data 0 name) "drawable-group") + (+! (-> arg0 data 0 count) 1) + (let ((v1-6 (asize-of obj))) + (+! (-> arg0 data 0 used) v1-6) + (+! (-> arg0 data 0 total) (logand -16 (+ v1-6 15))) + ) + (when (nonzero? (-> obj time-of-day-pal)) + (set! (-> arg0 length) (max 9 (-> arg0 length))) + (set! (-> arg0 data 8 name) "tfragment-pal") + (+! (-> arg0 data 8 count) 1) + (let ((v1-18 (asize-of (-> obj time-of-day-pal)))) + (+! (-> arg0 data 8 used) v1-18) + (+! (-> arg0 data 8 total) (logand -16 (+ v1-18 15))) + ) + ) + (dotimes (s3-0 (-> obj length)) + (mem-usage (-> obj arrays s3-0) arg0 arg1) + ) + obj + ) + +(defmethod asize-of drawable-inline-array-tfrag ((obj drawable-inline-array-tfrag)) + (the-as int (+ (-> drawable-inline-array-tfrag size) (* (+ (-> obj length) -1) 64))) + ) + +(define *tfrag-display-stats* #f) + +(define tfrag-vu1-block (new 'static 'vu-function :length 0 :qlength 0)) + +(defun tfrag-data-setup ((arg0 tfrag-data) (arg1 int) (arg2 int)) + (let ((v1-0 *math-camera*)) + (set-vector! (-> arg0 fog) (-> v1-0 pfog0) (-> v1-0 fog-min) (-> v1-0 fog-max) 3072.0) + (set-vector! (-> arg0 val) 0.5 1.0 2048.0 0.0) + (set-vector! (-> arg0 ambient) 1.0 1.0 1.0 1.0) + (let ((a0-4 arg2)) + (cond + ((zero? a0-4) + (set! (-> arg0 strgif tag) + (new 'static 'gif-tag64 + :pre #x1 + :nreg #x3 + :prim (new 'static 'gs-prim :prim (gs-prim-type tri-strip) :iip #x1 :tme #x1 :fge #x1 :abe arg1) + ) + ) + (set! (-> arg0 fangif tag) + (new 'static 'gif-tag64 + :pre #x1 + :nreg #x3 + :prim (new 'static 'gs-prim :prim (gs-prim-type tri-fan) :iip #x1 :tme #x1 :fge #x1 :abe arg1) + ) + ) + ) + ((= a0-4 1) + (set! (-> arg0 strgif tag) + (new 'static 'gif-tag64 + :pre #x1 + :nreg #x3 + :prim (new 'static 'gs-prim :prim (gs-prim-type line-strip) :iip #x1 :tme #x1 :fge #x1 :abe arg1) + ) + ) + (set! (-> arg0 fangif tag) + (new 'static 'gif-tag64 + :pre #x1 + :nreg #x3 + :prim (new 'static 'gs-prim :prim (gs-prim-type line-strip) :iip #x1 :tme #x1 :fge #x1 :abe arg1) + ) + ) + ) + ((= a0-4 2) + (set! (-> arg0 strgif tag) + (new 'static 'gif-tag64 + :pre #x1 + :nreg #x3 + :prim (new 'static 'gs-prim :prim (gs-prim-type tri-strip) :iip #x1 :fge #x1 :abe arg1) + ) + ) + (set! (-> arg0 fangif tag) + (new 'static 'gif-tag64 + :pre #x1 + :nreg #x3 + :prim (new 'static 'gs-prim :prim (gs-prim-type tri-fan) :iip #x1 :fge #x1 :abe arg1) + ) + ) + ) + ((= a0-4 3) + (set! (-> arg0 strgif tag) + (new 'static 'gif-tag64 + :pre #x1 + :nreg #x3 + :prim (new 'static 'gs-prim :prim (gs-prim-type line-strip) :iip #x1 :tme #x1 :fge #x1 :abe arg1) + ) + ) + (set! (-> arg0 fangif tag) + (new 'static 'gif-tag64 + :pre #x1 + :nreg #x3 + :prim (new 'static 'gs-prim :prim (gs-prim-type tri-fan) :iip #x1 :tme #x1 :fge #x1 :abe arg1) + ) + ) + ) + ) + ) + (set! (-> arg0 strgif regs) + (new 'static 'gif-tag-regs :regs0 (gif-reg-id st) :regs1 (gif-reg-id rgbaq) :regs2 (gif-reg-id xyzf2)) + ) + (set! (-> arg0 fangif regs) + (new 'static 'gif-tag-regs :regs0 (gif-reg-id st) :regs1 (gif-reg-id rgbaq) :regs2 (gif-reg-id xyzf2)) + ) + (set! (-> arg0 adgif tag) (new 'static 'gif-tag64 :nloop #x5 :nreg #x1)) + (set! (-> arg0 adgif regs) (new 'static 'gif-tag-regs :regs0 (gif-reg-id a+d))) + (set! (-> arg0 hvdf-offset quad) (-> v1-0 hvdf-off quad)) + (set! (-> arg0 hmge-scale quad) (-> v1-0 hmge-scale quad)) + (set! (-> arg0 invh-scale quad) (-> v1-0 inv-hmge-scale quad)) + (set! (-> arg0 guard quad) (-> v1-0 guard quad)) + ) + (set-tfrag-dists! (-> arg0 dists)) + (none) + ) + +(defun add-tfrag-mtx-0 ((arg0 dma-buffer) (arg1 symbol)) + (let* ((a2-0 4) + (v1-0 arg0) + (a0-1 (the-as dma-packet (-> v1-0 base))) + ) + (set! (-> a0-1 dma) (new 'static 'dma-tag :id (dma-tag-id cnt) :qwc a2-0)) + (set! (-> a0-1 vif0) (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl))) + (set! (-> a0-1 vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd unpack-v4-32) :num a2-0)) + (set! (-> v1-0 base) (the-as pointer (&+ a0-1 16))) + ) + (if arg1 + (column-scale-matrix! + (the-as matrix (-> arg0 base)) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0) + (-> *math-camera* camera-temp-other) + ) + (column-scale-matrix! + (the-as matrix (-> arg0 base)) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0) + (-> *math-camera* camera-temp) + ) + ) + (&+! (-> arg0 base) 64) + (none) + ) + +(defun add-tfrag-mtx-1 ((arg0 dma-buffer) (arg1 symbol)) + (let* ((a2-0 4) + (v1-0 arg0) + (a0-1 (the-as dma-packet (-> v1-0 base))) + ) + (set! (-> a0-1 dma) (new 'static 'dma-tag :id (dma-tag-id cnt) :qwc a2-0)) + (set! (-> a0-1 vif0) (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl))) + (set! (-> a0-1 vif1) (new 'static 'vif-tag :imm #x14d :cmd (vif-cmd unpack-v4-32) :num a2-0)) + (set! (-> v1-0 base) (the-as pointer (&+ a0-1 16))) + ) + (if arg1 + (column-scale-matrix! + (the-as matrix (-> arg0 base)) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0) + (-> *math-camera* camera-temp-other) + ) + (column-scale-matrix! + (the-as matrix (-> arg0 base)) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0) + (-> *math-camera* camera-temp) + ) + ) + (&+! (-> arg0 base) 64) + (none) + ) + +(defun add-tfrag-data ((arg0 dma-buffer) (arg1 int) (arg2 int)) + (let* ((a3-0 14) + (v1-0 arg0) + (a0-1 (the-as dma-packet (-> v1-0 base))) + ) + (set! (-> a0-1 dma) (new 'static 'dma-tag :id (dma-tag-id cnt) :qwc a3-0)) + (set! (-> a0-1 vif0) (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl))) + (set! (-> a0-1 vif1) (new 'static 'vif-tag :imm #x290 :cmd (vif-cmd unpack-v4-32) :num a3-0)) + (set! (-> v1-0 base) (the-as pointer (&+ a0-1 16))) + ) + (tfrag-data-setup (the-as tfrag-data (-> arg0 base)) arg1 arg2) + (&+! (-> arg0 base) 224) + (let ((v1-3 (the-as dma-packet (-> arg0 base)))) + (set! (-> v1-3 dma) (new 'static 'dma-tag :id (dma-tag-id cnt))) + (set! (-> v1-3 vif0) (new 'static 'vif-tag)) + (set! (-> v1-3 vif1) (new 'static 'vif-tag :cmd (vif-cmd mscal) :msk #x1)) + (set! (-> arg0 base) (the-as pointer (&+ v1-3 16))) + ) + (none) + ) + +(defun add-pc-tfrag3-data ((dma-buf dma-buffer) (lev level)) + "Add PC-port specific tfrag data" + (let ((packet (the-as dma-packet (-> dma-buf base)))) + (set! (-> packet dma) (new 'static 'dma-tag :id (dma-tag-id cnt) :qwc 16)) + (set! (-> packet vif0) (new 'static 'vif-tag)) + (set! (-> packet vif1) (new 'static 'vif-tag :cmd (vif-cmd pc-port))) + (set! (-> dma-buf base) (the pointer (&+ packet 16))) + ) + + ;; first 4 quadwords are planes, then itimes + (let ((data-ptr (the-as (pointer uint128) (-> dma-buf base)))) + (set! (-> data-ptr 0) (-> *math-camera* plane 0 quad)) + (set! (-> data-ptr 1) (-> *math-camera* plane 1 quad)) + (set! (-> data-ptr 2) (-> *math-camera* plane 2 quad)) + (set! (-> data-ptr 3) (-> *math-camera* plane 3 quad)) + ; (set! (-> data-ptr 4) (-> lev mood itimes 0 quad)) todo, time of dayl + ; (set! (-> data-ptr 5) (-> lev mood itimes 1 quad)) + ; (set! (-> data-ptr 6) (-> lev mood itimes 2 quad)) + ; (set! (-> data-ptr 7) (-> lev mood itimes 3 quad)) + (set! (-> data-ptr 8) (-> *math-camera* camera-temp vector 0 quad)) + (set! (-> data-ptr 9) (-> *math-camera* camera-temp vector 1 quad)) + (set! (-> data-ptr 10) (-> *math-camera* camera-temp vector 2 quad)) + (set! (-> data-ptr 11) (-> *math-camera* camera-temp vector 3 quad)) + (set! (-> data-ptr 12) (-> *math-camera* hvdf-off quad)) + (let ((vec (-> (the (inline-array vector) data-ptr) 13))) + (set! (-> vec x) (-> *math-camera* pfog0)) + (set! (-> vec y) (-> *math-camera* fog-min)) + (set! (-> vec z) (-> *math-camera* fog-max)) + ) + (set! (-> data-ptr 14) (-> (math-camera-pos) quad)) + (charp<-string (the (pointer uint8) (&-> data-ptr 15)) (symbol->string (-> lev nickname))) + ) + (&+! (-> dma-buf base) (* 16 16)) + ) + +(define t-stat (new 'global 'tfrag-stats)) + +(defun tfrag-print-stats ((arg0 symbol)) + (when (and *tfrag-display-stats* (!= *master-mode* 'menu)) + (format arg0 "~%") + (format arg0 "tris: ~8d~%" (-> t-stat tris)) + (format arg0 "verts: ~8d~%" (+ (-> t-stat base-verts) (-> t-stat level0-verts) (-> t-stat level1-verts))) + (format arg0 " base: ~8d~%" (-> t-stat base-verts)) + (format arg0 " lev0: ~8d~%" (-> t-stat level0-verts)) + (format arg0 " lev1: ~8d~%" (-> t-stat level1-verts)) + (format arg0 "tfaces: ~8d~%" (-> t-stat tfaces)) + (format arg0 "tfrags: ~8d~%" (-> t-stat tfrags)) + (format arg0 "dtris: ~8d~%" (-> t-stat dtris)) + (format arg0 "dps: ~8d~%" (-> t-stat drawpoints)) + (format arg0 "strips: ~8d~%" (-> t-stat strips)) + (format arg0 "shaders:~8d~%" (-> t-stat dma-tex)) + (format arg0 "tri/str:~8f~%" (/ (the float (-> t-stat dtris)) (the float (-> t-stat strips)))) + (format arg0 "dma-cnt:~8d (~8d)~%" (-> t-stat dma-cnt) (* (-> t-stat dma-cnt) 32)) + (format arg0 "dma-dta:~8d (~8d)~%" (-> t-stat dma-dta) (/ (* 33 (-> t-stat dma-dta)) 10)) + (let ((f0-4 (* 32.0 (the float (-> t-stat dma-cnt)))) + (f1-5 (* 3.3 (the float (-> t-stat dma-dta)))) + (f2-3 (* 30.0 (the float (-> t-stat tfrags)))) + ) + (+ f0-4 f1-5 f2-3) + ) + ) + (none) + ) + +(set! (-> t-stat from) 0) +(set! (-> t-stat to) 0) +(set! (-> t-stat cnt) 0) + +(defun tfrag-init-buffer ((arg0 dma-buffer) (arg1 gs-test) (arg2 int) (arg3 symbol)) + (dma-buffer-add-vu-function arg0 tfrag-vu1-block 1) + (let* ((v1-0 arg0) + (a0-2 (the-as dma-packet (-> v1-0 base))) + ) + (set! (-> a0-2 dma) (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt))) + (set! (-> a0-2 vif0) (new 'static 'vif-tag)) + (set! (-> a0-2 vif1) (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1)) + (set! (-> v1-0 base) (the-as pointer (&+ a0-2 16))) + ) + (let* ((v1-1 arg0) + (a0-4 (the-as gs-gif-tag (-> v1-1 base))) + ) + (set! (-> a0-4 tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1)) + (set! (-> a0-4 regs) GIF_REGS_ALL_AD) + (set! (-> v1-1 base) (the-as pointer (&+ a0-4 16))) + ) + (let* ((v1-2 arg0) + (a0-6 (-> v1-2 base)) + ) + (set! (-> (the-as (pointer gs-test) a0-6)) arg1) + (set! (-> (the-as (pointer gs-reg64) a0-6) 1) (gs-reg64 test-1)) + (set! (-> v1-2 base) (&+ a0-6 16)) + ) + (add-tfrag-mtx-0 arg0 arg3) + (add-tfrag-mtx-1 arg0 arg3) + (add-tfrag-data arg0 arg2 (the-as int *subdivide-draw-mode*)) + (#when PC_PORT + (add-pc-tfrag3-data arg0 *pc-tfrag-draw-level*) + ) + (let ((v1-3 (the-as dma-packet (-> arg0 base)))) + (set! (-> v1-3 dma) (new 'static 'dma-tag :id (dma-tag-id cnt))) + (set! (-> v1-3 vif0) (new 'static 'vif-tag :cmd (vif-cmd base))) + (set! (-> v1-3 vif1) (new 'static 'vif-tag :imm #x148 :cmd (vif-cmd offset))) + (set! (-> arg0 base) (the-as pointer (&+ v1-3 16))) + ) + (none) + ) + +(defun tfrag-end-buffer ((arg0 dma-buffer) (arg1 int)) + (let* ((v1-0 arg0) + (a2-0 (the-as dma-packet (-> v1-0 base))) + ) + (set! (-> a2-0 dma) (new 'static 'dma-tag :qwc #x3 :id (dma-tag-id cnt))) + (set! (-> a2-0 vif0) (new 'static 'vif-tag :cmd (vif-cmd stmask))) + (set! (-> a2-0 vif1) (new 'static 'vif-tag)) + (set! (-> v1-0 base) (the-as pointer (&+ a2-0 16))) + ) + (let* ((v1-1 arg0) + (a0-1 (-> v1-1 base)) + ) + (set! (-> (the-as (pointer vif-tag) a0-1) 0) (the-as vif-tag arg1)) + (set! (-> (the-as (pointer vif-tag) a0-1) 1) (new 'static 'vif-tag :cmd (vif-cmd flusha) :msk #x1)) + (set! (-> (the-as (pointer vif-tag) a0-1) 2) (new 'static 'vif-tag :cmd (vif-cmd stmod))) + (set! (-> (the-as (pointer vif-tag) a0-1) 3) (new 'static 'vif-tag :cmd (vif-cmd strow) :msk #x1)) + (set! (-> (the-as (pointer int32) a0-1) 4) 0) + (set! (-> (the-as (pointer int32) a0-1) 5) 0) + (set! (-> (the-as (pointer int32) a0-1) 6) 0) + (set! (-> (the-as (pointer int32) a0-1) 7) 0) + (set! (-> (the-as (pointer vif-tag) a0-1) 8) (new 'static 'vif-tag :cmd (vif-cmd base))) + (set! (-> (the-as (pointer vif-tag) a0-1) 9) (new 'static 'vif-tag :cmd (vif-cmd offset))) + (set! (-> (the-as (pointer vif-tag) a0-1) 10) (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl))) + (set! (-> (the-as (pointer vif-tag) a0-1) 11) (new 'static 'vif-tag)) + (set! (-> v1-1 base) (&+ a0-1 48)) + ) + (none) + ) + +;; draw-inline-array-tfrag + +;; definition for function tfrag-scissor-init-buffer +(defun tfrag-scissor-init-buffer ((arg0 dma-buffer) (arg1 gs-test) (arg2 int) (arg3 symbol)) + (break!) + (none) + ) + +(defun tfrag-scissor-end-buffer ((arg0 dma-buffer) (arg1 uint)) + (break!) ;; not ported + (none) + ) + +;; draw-inline-array-tfrag-scissor + +;; stats-tfrag-asm +(defun stats-tfrag-asm ((frag tfragment)) + (format 0 "no stats for you~%") + (none) + ) + + + + diff --git a/goal_src/jak2/engine/gfx/vu1-user-h.gc b/goal_src/jak2/engine/gfx/vu1-user-h.gc index 9518700435..2fe7dcb4e8 100644 --- a/goal_src/jak2/engine/gfx/vu1-user-h.gc +++ b/goal_src/jak2/engine/gfx/vu1-user-h.gc @@ -27,10 +27,10 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (tex-l0-tfrag 7) ;; level 0 tex - (bucket-8 8) ;; tfrag + (tfrag-l0-tfrag 8) ;; tfrag (bucket-9 9) ;; tie (bucket-10 10) ;; tie - (bucket-11 11) ;; tfrag + (tfrag-s-l0-tfrag 11) ;; tfrag (bucket-12 12) ;; tie (bucket-13 13) ;; tie (merc-l0-tfrag 14) ;; merc @@ -39,10 +39,10 @@ (bucket-17 17) ;; tie (tex-l1-tfrag 18) ;; tex - (bucket-19 19) ;; tfrag + (tfrag-l1-tfrag 19) ;; tfrag (bucket-20 20) ;; tie (bucket-21 21) ;; tie - (bucket-22 22) ;; tfrag + (tfrag-s-l1-tfrag 22) ;; tfrag (bucket-23 23) ;; tie (bucket-24 24) ;; tie (merc-l1-tfrag 25) ;; merc @@ -51,10 +51,10 @@ (bucket-28 28) ;; tie (tex-l2-tfrag 29) ;; tex - (bucket-30 30) ;; tfrag + (tfrag-l2-tfrag 30) ;; tfrag (bucket-31 31) ;; tie (bucket-32 32) ;; tie - (bucket-33 33) ;; tfrag + (tfrag-s-l2-tfrag 33) ;; tfrag (bucket-34 34) ;; tie (bucket-35 35) ;; tie (merc-l2-tfrag 36) ;; merc @@ -63,10 +63,10 @@ (bucket-39 39) ;; tie (tex-l3-tfrag 40) ;; tex - (bucket-41 41) ;; tfrag + (tfrag-l3-tfrag 41) ;; tfrag (bucket-42 42) ;; tie (bucket-43 43) ;; tie - (bucket-44 44) ;; tfrag + (tfrag-s-l3-tfrag 44) ;; tfrag (bucket-45 45) ;; tie (bucket-46 46) ;; tie (merc-l3-tfrag 47) ;; merc @@ -75,10 +75,10 @@ (bucket-50 50) ;; tie (tex-l4-tfrag 51) ;; tex - (bucket-52 52) ;; tfrag + (tfrag-l4-tfrag 52) ;; tfrag (bucket-53 53) ;; tie (bucket-54 54) ;; tie - (bucket-55 55) ;; tfrag + (tfrag-s-l4-tfrag 55) ;; tfrag (bucket-56 56) ;; tie (bucket-57 57) ;; tie (merc-l4-tfrag 58) ;; merc @@ -87,10 +87,10 @@ (bucket-61 61) ;; tie (tex-l5-tfrag 62) ;; tex - (bucket-63 63) ;; tfrag + (tfrag-l5-tfrag 63) ;; tfrag (bucket-64 64) ;; tie (bucket-65 65) ;; tie - (bucket-66 66) ;; tfrag + (tfrag-s-l5-tfrag 66) ;; tfrag (bucket-67 67) ;; tie (bucket-68 68) ;; tie (merc-l5-tfrag 69) ;; merc @@ -102,299 +102,299 @@ ;; All levels with shrub tpage ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - (tex-l0-shrub 73) ;; tex - (bucket-74 74) ;; shrub - (bucket-75 75) ;; shrub - (bucket-76 76) ;; shrub - (bucket-77 77) ;; shrub - (bucket-78 78) ;; shrub - (merc-l0-shrub 79) ;; merc - (emerc-l0-shrub 80) ;; emerc - (bucket-81 81) ;; mercneric + (tex-l0-shrub 73) ;; tex + (bucket-74 74) ;; shrub + (bucket-75 75) ;; shrub + (bucket-76 76) ;; shrub + (bucket-77 77) ;; shrub + (bucket-78 78) ;; shrub + (merc-l0-shrub 79) ;; merc + (emerc-l0-shrub 80) ;; emerc + (bucket-81 81) ;; mercneric - (tex-l1-shrub 82) ;; tex - (bucket-83 83) ;; shrub - (bucket-84 84) ;; shrub - (bucket-85 85) ;; shrub - (bucket-86 86) ;; shrub - (bucket-87 87) ;; shrub - (merc-l1-shrub 88) ;; merc - (emerc-l1-shrub 89) ;; emerc - (bucket-90 90) ;; mercneric + (tex-l1-shrub 82) ;; tex + (bucket-83 83) ;; shrub + (bucket-84 84) ;; shrub + (bucket-85 85) ;; shrub + (bucket-86 86) ;; shrub + (bucket-87 87) ;; shrub + (merc-l1-shrub 88) ;; merc + (emerc-l1-shrub 89) ;; emerc + (bucket-90 90) ;; mercneric - (tex-l2-shrub 91) ;; tex - (bucket-92 92) ;; shrub - (bucket-93 93) ;; shrub - (bucket-94 94) ;; shrub - (bucket-95 95) ;; shrub - (bucket-96 96) ;; shrub - (merc-l2-shrub 97) ;; merc - (emerc-l2-shrub 98) ;; emerc - (bucket-99 99) ;; mercneric + (tex-l2-shrub 91) ;; tex + (bucket-92 92) ;; shrub + (bucket-93 93) ;; shrub + (bucket-94 94) ;; shrub + (bucket-95 95) ;; shrub + (bucket-96 96) ;; shrub + (merc-l2-shrub 97) ;; merc + (emerc-l2-shrub 98) ;; emerc + (bucket-99 99) ;; mercneric - (tex-l3-shrub 100) ;; tex - (bucket-101 101) ;; shrub - (bucket-102 102) ;; shrub - (bucket-103 103) ;; shrub - (bucket-104 104) ;; shrub - (bucket-105 105) ;; shrub - (merc-l3-shrub 106) ;; merc - (emerc-l3-shrub 107) ;; emerc - (bucket-108 108) ;; mercneric + (tex-l3-shrub 100) ;; tex + (bucket-101 101) ;; shrub + (bucket-102 102) ;; shrub + (bucket-103 103) ;; shrub + (bucket-104 104) ;; shrub + (bucket-105 105) ;; shrub + (merc-l3-shrub 106) ;; merc + (emerc-l3-shrub 107) ;; emerc + (bucket-108 108) ;; mercneric - (tex-l4-shrub 109) ;; tex - (bucket-110 110) ;; shrub - (bucket-111 111) ;; shrub - (bucket-112 112) ;; shrub - (bucket-113 113) ;; shrub - (bucket-114 114) ;; shrub - (merc-l4-shrub 115) ;; merc - (emerc-l4-shrub 116) ;; emerc - (bucket-117 117) ;; mercneric + (tex-l4-shrub 109) ;; tex + (bucket-110 110) ;; shrub + (bucket-111 111) ;; shrub + (bucket-112 112) ;; shrub + (bucket-113 113) ;; shrub + (bucket-114 114) ;; shrub + (merc-l4-shrub 115) ;; merc + (emerc-l4-shrub 116) ;; emerc + (bucket-117 117) ;; mercneric - (tex-l5-shrub 118) ;; tex - (bucket-119 119) ;; shrub - (bucket-120 120) ;; shrub - (bucket-121 121) ;; shrub - (bucket-122 122) ;; shrub - (bucket-123 123) ;; shrub - (merc-l5-shrub 124) ;; merc - (emerc-l5-shrub 125) ;; emerc - (bucket-126 126) ;; mercneric + (tex-l5-shrub 118) ;; tex + (bucket-119 119) ;; shrub + (bucket-120 120) ;; shrub + (bucket-121 121) ;; shrub + (bucket-122 122) ;; shrub + (bucket-123 123) ;; shrub + (merc-l5-shrub 124) ;; merc + (emerc-l5-shrub 125) ;; emerc + (bucket-126 126) ;; mercneric - (tex-l0-alpha 127) ;; tex - (bucket-128 128) ;; tfrag - (bucket-129 129) ;; tie - (bucket-130 130) ;; tie - (merc-l0-alpha 131) ;; merc - (emerc-l0-alpha 132) ;; emerc - (bucket-133 133) ;; mercneric - (bucket-134 134) ;; tfrag - (bucket-135 135) ;; tie - (bucket-136 136) ;; tie + (tex-l0-alpha 127) ;; tex + (tfrag-t-l0-alpha 128) ;; tfrag + (bucket-129 129) ;; tie + (bucket-130 130) ;; tie + (merc-l0-alpha 131) ;; merc + (emerc-l0-alpha 132) ;; emerc + (bucket-133 133) ;; mercneric + (tfrag-st-l0-alpha 134) ;; tfrag + (bucket-135 135) ;; tie + (bucket-136 136) ;; tie - (tex-l1-alpha 137) ;; tex - (bucket-138 138) ;; tfrag - (bucket-139 139) ;; tie - (bucket-140 140) ;; tie - (merc-l1-alpha 141) ;; merc - (emerc-l1-alpha 142) ;; emerc - (bucket-143 143) ;; mercneric - (bucket-144 144) ;; tfrag - (bucket-145 145) ;; tie - (bucket-146 146) ;; tie + (tex-l1-alpha 137) ;; tex + (tfrag-t-l1-alpha 138) ;; tfrag + (bucket-139 139) ;; tie + (bucket-140 140) ;; tie + (merc-l1-alpha 141) ;; merc + (emerc-l1-alpha 142) ;; emerc + (bucket-143 143) ;; mercneric + (tfrag-st-l1-alpha 144) ;; tfrag + (bucket-145 145) ;; tie + (bucket-146 146) ;; tie - (tex-l2-alpha 147) ;; tex - (bucket-148 148) ;; tfrag - (bucket-149 149) ;; tie - (bucket-150 150) ;; tie - (merc-l2-alpha 151) ;; merc - (emerc-l2-alpha 152) ;; emerc - (bucket-153 153) ;; mercneric - (bucket-154 154) ;; tfrag - (bucket-155 155) ;; tie - (bucket-156 156) ;; tie + (tex-l2-alpha 147) ;; tex + (tfrag-t-l2-alpha 148) ;; tfrag + (bucket-149 149) ;; tie + (bucket-150 150) ;; tie + (merc-l2-alpha 151) ;; merc + (emerc-l2-alpha 152) ;; emerc + (bucket-153 153) ;; mercneric + (tfrag-st-l2-alpha 154) ;; tfrag + (bucket-155 155) ;; tie + (bucket-156 156) ;; tie - (tex-l3-alpha 157) ;; tex - (bucket-158 158) ;; tfrag - (bucket-159 159) ;; tie - (bucket-160 160) ;; tie - (merc-l3-alpha 161) ;; merc - (emerc-l3-alpha 162) ;; emerc - (bucket-163 163) ;; mercneric - (bucket-164 164) ;; tfrag - (bucket-165 165) ;; tie - (bucket-166 166) ;; tie + (tex-l3-alpha 157) ;; tex + (tfrag-t-l3-alpha 158) ;; tfrag + (bucket-159 159) ;; tie + (bucket-160 160) ;; tie + (merc-l3-alpha 161) ;; merc + (emerc-l3-alpha 162) ;; emerc + (bucket-163 163) ;; mercneric + (tfrag-st-l3-alpha 164) ;; tfrag + (bucket-165 165) ;; tie + (bucket-166 166) ;; tie - (tex-l4-alpha 167) ;; tex - (bucket-168 168) ;; tfrag - (bucket-169 169) ;; tie - (bucket-170 170) ;; tie - (merc-l4-alpha 171) ;; merc - (emerc-l4-alpha 172) ;; emerc - (bucket-173 173) ;; mercneric - (bucket-174 174) ;; tfrag - (bucket-175 175) ;; tie - (bucket-176 176) ;; tie + (tex-l4-alpha 167) ;; tex + (tfrag-t-l4-alpha 168) ;; tfrag + (bucket-169 169) ;; tie + (bucket-170 170) ;; tie + (merc-l4-alpha 171) ;; merc + (emerc-l4-alpha 172) ;; emerc + (bucket-173 173) ;; mercneric + (tfrag-st-l4-alpha 174) ;; tfrag + (bucket-175 175) ;; tie + (bucket-176 176) ;; tie - (tex-l5-alpha 177) ;; tex - (bucket-178 178) ;; tfrag - (bucket-179 179) ;; tie - (bucket-180 180) ;; tie - (merc-l5-alpha 181) ;; merc - (emerc-l5-alpha 182) ;; emerc - (bucket-183 183) ;; mercneric - (bucket-184 184) ;; tfrag - (bucket-185 185) ;; tie - (bucket-186 186) ;; tie + (tex-l5-alpha 177) ;; tex + (tfrag-t-l5-alpha 178) ;; tfrag + (bucket-179 179) ;; tie + (bucket-180 180) ;; tie + (merc-l5-alpha 181) ;; merc + (emerc-l5-alpha 182) ;; emerc + (bucket-183 183) ;; mercneric + (tfrag-st-l5-alpha 184) ;; tfrag + (bucket-185 185) ;; tie + (bucket-186 186) ;; tie - (tex-lcom-tfrag 187) ;; tex - (merc-lcom-tfrag 188) ;; merc - (emerc-lcom-tfrag 189) ;; emerc - (bucket-190 190) ;; mercneric + (tex-lcom-tfrag 187) ;; tex + (merc-lcom-tfrag 188) ;; merc + (emerc-lcom-tfrag 189) ;; emerc + (bucket-190 190) ;; mercneric - (tex-lcom-shrub 191) ;; tex - (merc-lcom-shrub 192) ;; merc - (emerc-lcom-shrub 193) ;; emerc - (bucket-194 194) ;; mercneric + (tex-lcom-shrub 191) ;; tex + (merc-lcom-shrub 192) ;; merc + (emerc-lcom-shrub 193) ;; emerc + (bucket-194 194) ;; mercneric - (bucket-195 195) ;; shadow + (bucket-195 195) ;; shadow - (tex-l0-pris 196) ;; tex - (merc-l0-pris 197) ;; merc - (emerc-l0-pris 198) ;; emerc - (bucket-199 199) ;; mercneric + (tex-l0-pris 196) ;; tex + (merc-l0-pris 197) ;; merc + (emerc-l0-pris 198) ;; emerc + (bucket-199 199) ;; mercneric - (tex-l1-pris 200) ;; tex - (merc-l1-pris 201) ;; merc - (emerc-l1-pris 202) ;; emerc - (bucket-203 203) ;; mercneric + (tex-l1-pris 200) ;; tex + (merc-l1-pris 201) ;; merc + (emerc-l1-pris 202) ;; emerc + (bucket-203 203) ;; mercneric - (tex-l2-pris 204) ;; tex - (merc-l2-pris 205) ;; merc - (emerc-l2-pris 206) ;; emerc - (bucket-207 207) ;; mercneric + (tex-l2-pris 204) ;; tex + (merc-l2-pris 205) ;; merc + (emerc-l2-pris 206) ;; emerc + (bucket-207 207) ;; mercneric - (tex-l3-pris 208) ;; tex - (merc-l3-pris 209) ;; merc - (emerc-l3-pris 210) ;; emerc - (bucket-211 211) ;; mercneric + (tex-l3-pris 208) ;; tex + (merc-l3-pris 209) ;; merc + (emerc-l3-pris 210) ;; emerc + (bucket-211 211) ;; mercneric - (tex-l4-pris 212) ;; tex - (merc-l4-pris 213) ;; merc - (emerc-l4-pris 214) ;; emerc - (bucket-215 215) ;; mercneric + (tex-l4-pris 212) ;; tex + (merc-l4-pris 213) ;; merc + (emerc-l4-pris 214) ;; emerc + (bucket-215 215) ;; mercneric - (tex-l5-pris 216) ;; tex - (merc-l5-pris 217) ;; merc - (emerc-l5-pris 218) ;; emerc - (bucket-219 219) ;; mercneric + (tex-l5-pris 216) ;; tex + (merc-l5-pris 217) ;; merc + (emerc-l5-pris 218) ;; emerc + (bucket-219 219) ;; mercneric - (tex-lcom-pris 220) ;; tex - (merc-lcom-pris 221) ;; merc - (emerc-lcom-pris 222) ;; emerc - (bucket-223 223) ;; mercneric + (tex-lcom-pris 220) ;; tex + (merc-lcom-pris 221) ;; merc + (emerc-lcom-pris 222) ;; emerc + (bucket-223 223) ;; mercneric - (tex-l0-pris2 224) ;; tex - (merc-l0-pris2 225) ;; merc - (emerc-l0-pris2 226) ;; emerc - (bucket-227 227) ;; mercneric + (tex-l0-pris2 224) ;; tex + (merc-l0-pris2 225) ;; merc + (emerc-l0-pris2 226) ;; emerc + (bucket-227 227) ;; mercneric - (tex-l1-pris2 228) ;; tex - (merc-l1-pris2 229) ;; merc - (emerc-l1-pris2 230) ;; emerc - (bucket-231 231) ;; mercneric + (tex-l1-pris2 228) ;; tex + (merc-l1-pris2 229) ;; merc + (emerc-l1-pris2 230) ;; emerc + (bucket-231 231) ;; mercneric - (tex-l2-pris2 232) ;; tex - (merc-l2-pris2 233) ;; merc - (emerc-l2-pris2 234) ;; emerc - (bucket-235 235) ;; mercneric + (tex-l2-pris2 232) ;; tex + (merc-l2-pris2 233) ;; merc + (emerc-l2-pris2 234) ;; emerc + (bucket-235 235) ;; mercneric - (tex-l3-pris2 236) ;; tex - (merc-l3-pris2 237) ;; merc - (emerc-l3-pris2 238) ;; emerc - (bucket-239 239) ;; mercneric + (tex-l3-pris2 236) ;; tex + (merc-l3-pris2 237) ;; merc + (emerc-l3-pris2 238) ;; emerc + (bucket-239 239) ;; mercneric - (tex-l4-pris2 240) ;; tex - (merc-l4-pris2 241) ;; merc - (emerc-l4-pris2 242) ;; emerc - (bucket-243 243) ;; mercneric + (tex-l4-pris2 240) ;; tex + (merc-l4-pris2 241) ;; merc + (emerc-l4-pris2 242) ;; emerc + (bucket-243 243) ;; mercneric - (tex-l5-pris2 244) ;; tex - (merc-l5-pris2 245) ;; merc - (emerc-l5-pris2 246) ;; emerc - (bucket-247 247) ;; mercneric + (tex-l5-pris2 244) ;; tex + (merc-l5-pris2 245) ;; merc + (emerc-l5-pris2 246) ;; emerc + (bucket-247 247) ;; mercneric - (tex-lcom-pris2 248) ;; tex - (merc-lcom-pris2 249) ;; merc - (emerc-lcom-pris2 250) ;; emerc - (bucket-251 251) ;; mercneric + (tex-lcom-pris2 248) ;; tex + (merc-lcom-pris2 249) ;; merc + (emerc-lcom-pris2 250) ;; emerc + (bucket-251 251) ;; mercneric - (tex-l0-water 252) ;; tex - (merc-l0-water 253) ;; merc - (bucket-254 254) ;; mercneric - (bucket-255 255) ;; tfrag - (bucket-256 256) - (bucket-257 257) - (bucket-258 258) - (bucket-259 259) ;; tfrag - (bucket-260 260) + (tex-l0-water 252) ;; tex + (merc-l0-water 253) ;; merc + (bucket-254 254) ;; mercneric + (tfrag-w-l0-water 255) ;; tfrag + (bucket-256 256) + (bucket-257 257) + (bucket-258 258) + (tfrag-ws-l0-water 259) ;; tfrag + (bucket-260 260) - (tex-l1-water 261) ;; tex - (merc-l1-water 262) ;; merc - (bucket-263 263) ;; mercneric - (bucket-264 264) ;; tfrag - (bucket-265 265) - (bucket-266 266) - (bucket-267 267) - (bucket-268 268) ;; tfrag - (bucket-269 269) + (tex-l1-water 261) ;; tex + (merc-l1-water 262) ;; merc + (bucket-263 263) ;; mercneric + (tfrag-w-l1-water 264) ;; tfrag + (bucket-265 265) + (bucket-266 266) + (bucket-267 267) + (tfrag-ws-l1-water 268) ;; tfrag + (bucket-269 269) - (tex-l2-water 270) ;; tex - (merc-l2-water 271) ;; merc - (bucket-272 272) ;; mercneric - (bucket-273 273) ;; tfrag - (bucket-274 274) - (bucket-275 275) - (bucket-276 276) - (bucket-277 277) ;; tfrag - (bucket-278 278) + (tex-l2-water 270) ;; tex + (merc-l2-water 271) ;; merc + (bucket-272 272) ;; mercneric + (tfrag-w-l2-water 273) ;; tfrag + (bucket-274 274) + (bucket-275 275) + (bucket-276 276) + (tfrag-ws-l2-water 277) ;; tfrag + (bucket-278 278) - (tex-l3-water 279) ;; tex - (merc-l3-water 280) ;; merc - (bucket-281 281) ;; mercneric - (bucket-282 282) ;; tfrag - (bucket-283 283) - (bucket-284 284) - (bucket-285 285) - (bucket-286 286) ;; tfrag - (bucket-287 287) + (tex-l3-water 279) ;; tex + (merc-l3-water 280) ;; merc + (bucket-281 281) ;; mercneric + (tfrag-w-l3-water 282) ;; tfrag + (bucket-283 283) + (bucket-284 284) + (bucket-285 285) + (tfrag-ws-l3-water 286) ;; tfrag + (bucket-287 287) - (tex-l4-water 288) ;; tex - (merc-l4-water 289) ;; merc - (bucket-290 290) ;; mercneric - (bucket-291 291) ;; tfrag - (bucket-292 292) - (bucket-293 293) - (bucket-294 294) - (bucket-295 295) ;; tfrag - (bucket-296 296) + (tex-l4-water 288) ;; tex + (merc-l4-water 289) ;; merc + (bucket-290 290) ;; mercneric + (tfrag-w-l4-water 291) ;; tfrag + (bucket-292 292) + (bucket-293 293) + (bucket-294 294) + (tfrag-ws-l4-water 295) ;; tfrag + (bucket-296 296) - (tex-l5-water 297) ;; tex - (merc-l5-water 298) ;; merc - (bucket-299 299) ;; mercneric - (bucket-300 300) ;; tfrag - (bucket-301 301) - (bucket-302 302) - (bucket-303 303) - (bucket-304 304) ;; tfrag - (bucket-305 305) + (tex-l5-water 297) ;; tex + (merc-l5-water 298) ;; merc + (bucket-299 299) ;; mercneric + (tfrag-w-l5-water 300) ;; tfrag + (bucket-301 301) + (bucket-302 302) + (bucket-303 303) + (tfrag-ws-l5-water 304) ;; tfrag + (bucket-305 305) - (tex-lcom-water 306) ;; tex - (merc-lcom-water 307) ;; merc - (bucket-308 308) ;; mercneric + (tex-lcom-water 306) ;; tex + (merc-lcom-water 307) ;; merc + (bucket-308 308) ;; mercneric - (tex-lcom-sky-post 309) + (tex-lcom-sky-post 309) - (bucket-310 310) ;; ocean - (bucket-311 311) ;; depth-cue + (bucket-310 310) ;; ocean + (bucket-311 311) ;; depth-cue - (tex-all-sprite 312) - (bucket-313 313) ;; particles - (bucket-314 314) ;; shadow - (bucket-315 315) ;; effects - (tex-all-warp 316) ;; tex - (bucket-317 317) ;; mercneric + (tex-all-sprite 312) + (bucket-313 313) ;; particles + (bucket-314 314) ;; shadow + (bucket-315 315) ;; effects + (tex-all-warp 316) ;; tex + (bucket-317 317) ;; mercneric - (debug-no-zbuf1 318) ;; debug, no zbuf - (tex-all-map 319) ;; tex - (bucket-320 320) ;; hud - (screen-filter 321) ;; hud letterbox, no zbuf - (bucket-322 322) ;; hud - (bucket-323 323) ;; hud - (debug2 324) ;; debug - (debug-no-zbuf2 325) ;; debug - (debug3 326) + (debug-no-zbuf1 318) ;; debug, no zbuf + (tex-all-map 319) ;; tex + (bucket-320 320) ;; hud + (screen-filter 321) ;; hud letterbox, no zbuf + (bucket-322 322) ;; hud + (bucket-323 323) ;; hud + (debug2 324) ;; debug + (debug-no-zbuf2 325) ;; debug + (debug3 326) ) (defenum vu1-renderer-mask @@ -406,7 +406,7 @@ (rn3) (rn4) (rn5) - (rn6) + (tfrag) (rn7) (rn8) (rn9) @@ -419,12 +419,12 @@ (rn16) (rn17) (rn18) - (rn19) + (tfrag-trans) (rn20) (rn21) (rn22) (rn23) - (rn24) + (tfrag-water) (rn25) (rn26) (rn27) diff --git a/goal_src/jak2/engine/level/bsp-h.gc b/goal_src/jak2/engine/level/bsp-h.gc index f361e8d283..ae1878a345 100644 --- a/goal_src/jak2/engine/level/bsp-h.gc +++ b/goal_src/jak2/engine/level/bsp-h.gc @@ -81,18 +81,25 @@ (region-array region-array :offset-assert 192) (collide-hash collide-hash :offset-assert 196) ;; 200 is some array - ;; 204 is maybe that array's length + (wind-array-length int32 :offset 204) ;; 216 is a vector array ;; (vec-array (pointer vector) :offset 216) ; TODO see - `update-visible` hits assertion (region-tree drawable-tree-region-prim :offset 252) (tfrag-masks texture-masks-array :offset-assert 256) - (tfrag-mask-count uint32 :offset-assert 260) + (tfrag-closest (pointer float) :offset-assert 260) + (tfrag-mask-count uint32 :offset 260) + (shrub-masks texture-masks-array :offset-assert 264) - (shrub-mask-count uint32 :offset-assert 268) + (shrub-closest (pointer float) :offset-assert 268) + (shrub-mask-count uint32 :offset 268) + (alpha-masks texture-masks-array :offset-assert 272) - (alpha-mask-count uint32 :offset-assert 276) + (alpha-closest (pointer float) :offset-assert 276) + (alpha-mask-count uint32 :offset 276) + (water-masks texture-masks-array :offset-assert 280) - (water-mask-count uint32 :offset-assert 284) + (water-closest (pointer float) :offset-assert 284) + (water-mask-count uint32 :offset 284) (bsp-scale vector :inline :offset-assert 288) (bsp-offset vector :inline :offset-assert 304) diff --git a/goal_src/jak2/engine/level/level-h.gc b/goal_src/jak2/engine/level/level-h.gc index d7b4383e4e..da2507436c 100644 --- a/goal_src/jak2/engine/level/level-h.gc +++ b/goal_src/jak2/engine/level/level-h.gc @@ -288,6 +288,7 @@ (water-masks texture-masks-array :offset-assert 5064) (water-dists pointer :offset-assert 5068) (tfrag-last-calls int32 6 :offset-assert 5072) + (tfrag-last-calls-u32 uint32 6 :offset 5072) (texture-anim-array texture-anim-array 10 :offset-assert 5096) (light-hash light-hash :offset-assert 5136) (draw-priority float :offset-assert 5140) diff --git a/goal_src/jak2/engine/level/level.gc b/goal_src/jak2/engine/level/level.gc index c9dbb05d17..23b2036115 100644 --- a/goal_src/jak2/engine/level/level.gc +++ b/goal_src/jak2/engine/level/level.gc @@ -763,6 +763,11 @@ ) (else (start-debug "load-begin, no borrow~%") + (dotimes (i 7) + (start-debug "lev ~8S bits #b~b~%" + (-> *level* level i name) + (-> *level* level i memory-mask)) + ) ;; not borrowing, we have to find our own memory. ;; there's a bit mask to indicate which sections of memory are used, with 6 bits. @@ -826,34 +831,34 @@ (((load-buffer-mode medium)) ;; need 3 bits in the mask. ;; like large, check both ends. - (when (memory-unused? *level* #xb000111) + (when (memory-unused? *level* #b000111) (set! bits-to-use 7) (goto cfg-83) ) - (when (memory-unused? *level* #xb111000) + (when (memory-unused? *level* #b111000) (set! offset-in-level-heap 73) ;; weird sizing - (set! bits-to-use #xb111000) + (set! bits-to-use #b111000) (goto cfg-83) ) ) (((load-buffer-mode small-center)) ;; only one place for us to go, in the center - (when (memory-unused? *level* #xb001100) + (when (memory-unused? *level* #b001100) (set! offset-in-level-heap 48) - (set! bits-to-use #xb1100) + (set! bits-to-use #b1100) (goto cfg-83) ) ) (((load-buffer-mode small-edge)) ;; check one side - (when (memory-unused? *level* #xb000011) - (set! bits-to-use #xb000011) + (when (memory-unused? *level* #b000011) + (set! bits-to-use #b000011) (goto cfg-83) ) ;; and the other - (when (memory-unused? *level* #xb110000) + (when (memory-unused? *level* #b110000) (set! offset-in-level-heap 98) - (set! bits-to-use #xb110000) + (set! bits-to-use #b110000) (goto cfg-83) ) ) @@ -905,7 +910,7 @@ 0 ) (else - (start-debug "successfully found load: size #x~X, bits #b~6,'0B, offset ~D~%" + (start-debug "successfully found load: size #x~X, bits #x~X, offset ~D~%" heap-size bits-to-use offset-in-level-heap) ;; found a spot, set mask. (set! (-> obj memory-mask) (the-as uint bits-to-use)) @@ -2148,7 +2153,7 @@ 'demo ) (*debug-segment* - 'prison + 'prison ;; 'ctysluma ) (else 'title @@ -2935,6 +2940,21 @@ (format *stdcon* "~3Lglobal heap fatally low at ~DK free~%~0L" (sar v1-186 10)) ) ) + + ;; pc port added + (let ((lev-names (new 'stack-no-clear 'array 'string 6))) + (dotimes (i 6) + (cond + ((= (-> obj level i status) 'inactive) + (set! (-> lev-names i) "none") + ) + (else + (set! (-> lev-names i) (symbol->string (-> obj level i nickname))) + ) + ) + ) + (__pc-set-levels lev-names) + ) 0 (none) ) diff --git a/goal_src/jak2/engine/util/profile.gc b/goal_src/jak2/engine/util/profile.gc index 4a637aab11..59e4b163f6 100644 --- a/goal_src/jak2/engine/util/profile.gc +++ b/goal_src/jak2/engine/util/profile.gc @@ -152,42 +152,42 @@ (defun profile-tfrag-test ((arg0 bucket-id)) "Is this a tfrag bucket?" - (or (= arg0 (bucket-id bucket-8)) - (= arg0 (bucket-id bucket-19)) - (= arg0 (bucket-id bucket-30)) - (= arg0 (bucket-id bucket-41)) - (= arg0 (bucket-id bucket-52)) - (= arg0 (bucket-id bucket-63)) - (= arg0 (bucket-id bucket-11)) - (= arg0 (bucket-id bucket-22)) - (= arg0 (bucket-id bucket-33)) - (= arg0 (bucket-id bucket-44)) - (= arg0 (bucket-id bucket-55)) - (= arg0 (bucket-id bucket-66)) - (= arg0 (bucket-id bucket-128)) - (= arg0 (bucket-id bucket-138)) - (= arg0 (bucket-id bucket-148)) - (= arg0 (bucket-id bucket-158)) - (= arg0 (bucket-id bucket-168)) - (= arg0 (bucket-id bucket-178)) - (= arg0 (bucket-id bucket-255)) - (= arg0 (bucket-id bucket-264)) - (= arg0 (bucket-id bucket-273)) - (= arg0 (bucket-id bucket-282)) - (= arg0 (bucket-id bucket-291)) - (= arg0 (bucket-id bucket-300)) - (= arg0 (bucket-id bucket-134)) - (= arg0 (bucket-id bucket-144)) - (= arg0 (bucket-id bucket-154)) - (= arg0 (bucket-id bucket-164)) - (= arg0 (bucket-id bucket-174)) - (= arg0 (bucket-id bucket-184)) - (= arg0 (bucket-id bucket-259)) - (= arg0 (bucket-id bucket-268)) - (= arg0 (bucket-id bucket-277)) - (= arg0 (bucket-id bucket-286)) - (= arg0 (bucket-id bucket-295)) - (= arg0 (bucket-id bucket-304)) + (or (= arg0 (bucket-id tfrag-l0-tfrag)) + (= arg0 (bucket-id tfrag-l1-tfrag)) + (= arg0 (bucket-id tfrag-l2-tfrag)) + (= arg0 (bucket-id tfrag-l3-tfrag)) + (= arg0 (bucket-id tfrag-l4-tfrag)) + (= arg0 (bucket-id tfrag-l5-tfrag)) + (= arg0 (bucket-id tfrag-s-l0-tfrag)) + (= arg0 (bucket-id tfrag-s-l1-tfrag)) + (= arg0 (bucket-id tfrag-s-l2-tfrag)) + (= arg0 (bucket-id tfrag-s-l3-tfrag)) + (= arg0 (bucket-id tfrag-s-l4-tfrag)) + (= arg0 (bucket-id tfrag-s-l5-tfrag)) + (= arg0 (bucket-id tfrag-t-l0-alpha)) + (= arg0 (bucket-id tfrag-t-l1-alpha)) + (= arg0 (bucket-id tfrag-t-l2-alpha)) + (= arg0 (bucket-id tfrag-t-l3-alpha)) + (= arg0 (bucket-id tfrag-t-l4-alpha)) + (= arg0 (bucket-id tfrag-t-l5-alpha)) + (= arg0 (bucket-id tfrag-w-l0-water)) + (= arg0 (bucket-id tfrag-w-l1-water)) + (= arg0 (bucket-id tfrag-w-l2-water)) + (= arg0 (bucket-id tfrag-w-l3-water)) + (= arg0 (bucket-id tfrag-w-l4-water)) + (= arg0 (bucket-id tfrag-w-l5-water)) + (= arg0 (bucket-id tfrag-st-l0-alpha)) + (= arg0 (bucket-id tfrag-st-l1-alpha)) + (= arg0 (bucket-id tfrag-st-l2-alpha)) + (= arg0 (bucket-id tfrag-st-l3-alpha)) + (= arg0 (bucket-id tfrag-st-l4-alpha)) + (= arg0 (bucket-id tfrag-st-l5-alpha)) + (= arg0 (bucket-id tfrag-ws-l0-water)) + (= arg0 (bucket-id tfrag-ws-l1-water)) + (= arg0 (bucket-id tfrag-ws-l2-water)) + (= arg0 (bucket-id tfrag-ws-l3-water)) + (= arg0 (bucket-id tfrag-ws-l4-water)) + (= arg0 (bucket-id tfrag-ws-l5-water)) ) ) diff --git a/goal_src/jak2/game.gp b/goal_src/jak2/game.gp index 11ebbc81e2..87b2f067fa 100644 --- a/goal_src/jak2/game.gp +++ b/goal_src/jak2/game.gp @@ -659,6 +659,13 @@ "blocking-plane-ag" ) +;;;;;;;;;;;;;;;;;;;;; +;; COMMON CITY STUFF +;;;;;;;;;;;;;;;;;;;;; + +(copy-gos + "fort-entry-gate-ag" + ) ;;;;;;;;;;;;;;;;;;;;; ;; PRISON @@ -683,11 +690,106 @@ "prsn-hang-cell-ag" "warp-gate-b-ag" "prsn-vent-fan-ag" - "fort-entry-gate-ag" "prsn-cell-door-ag" "prison-vis" ) +;;;;;;;;;;;;;;;;;;;;; +;; CITY WIDE +;;;;;;;;;;;;;;;;;;;;; + +(cgo "CWI.DGO" "cwi.gd") + +(goal-src-sequence + "levels/" + :deps ("$OUT/obj/los-control.o") + "city/common/nav-graph-h.gc" + "city/common/traffic-engine-h.gc" + "city/common/vehicle-h.gc" + "city/common/citizen-h.gc" + "city/common/height-map-h.gc" + "city/common/ctywide-obs-h.gc" + "city/common/height-map.gc" + "city/common/traffic-height-map.gc" + "city/common/nav-graph.gc" + "city/common/vehicle-rider.gc" + "city/common/vehicle-control.gc" + "city/common/vehicle-part.gc" + "city/common/vehicle-effects.gc" + "city/common/vehicle.gc" + "city/common/vehicle-util.gc" + "city/common/vehicle-physics.gc" + "city/common/vehicle-states.gc" + "city/common/vehicle-guard.gc" + "city/common/transport.gc" + "city/common/bike.gc" + "city/common/car.gc" + "city/common/test-bike.gc" + "city/common/test-car.gc" + "city/common/citizen.gc" + "city/common/civilian.gc" + "city/common/guard.gc" + "city/common/citizen-norm.gc" + "city/common/citizen-fat.gc" + "city/common/citizen-chick.gc" + "city/common/citizen-enemy.gc" + "city/common/metalhead-predator.gc" + "city/common/metalhead-grunt.gc" + "city/common/metalhead-flitter.gc" + "city/common/traffic-engine.gc" + "city/common/trail-graph.gc" + "city/common/trail.gc" + "city/common/traffic-manager.gc" + "city/common/ctywide-texture.gc" + "city/common/ctywide-part.gc" + "city/common/ctywide-obs.gc" + "city/common/ctywide-tasks.gc" + "city/common/ctywide-scenes.gc" + "city/common/ctywide-speech.gc" + "city/common/ctyport-obs.gc" + "city/common/target-pilot.gc" + "city/common/pilot-states.gc" + "city/common/searchlight.gc" + ) + +(copy-textures 1264 1266 1265 1674 1118 1657) + +(copy-gos + "jak-pilot+0-ag" + "baron-statue-ag" + "cty-guard-turret-ag" + "vehicle-explosion-ag" + "barons-ship-lores-ag" + "propa-ag" + "vehicle-turret-ag" + "lurker-pipe-lid-ag" + "searchlight-ag" + "burning-bush-ag" + "stadium-barrier-ag" + "security-wall-ag" + "ctywide-vis" + ) + +;;;;;;;;;;;;;;;;;;;;; +;; CITY SLUM A +;;;;;;;;;;;;;;;;;;;;; + +(cgo "CTA.DGO" "cta.gd") + +(goal-src-sequence + "levels/city/slums/" + :deps ("$OUT/obj/los-control.o") + "ctysluma-part.gc" + "neon-baron-part.gc" + ) + +(copy-textures 974 973 1680 1021 1646) + +(copy-gos +"cty-fruit-stand-ag" +"hide-door-a-ag" +"ctysluma-vis" +) ;;;;;;;;;;;;;;;;;;;;; ;; ISO Group diff --git a/goal_src/jak2/kernel-defs.gc b/goal_src/jak2/kernel-defs.gc index 55e74cb1f5..37f90dcfa6 100644 --- a/goal_src/jak2/kernel-defs.gc +++ b/goal_src/jak2/kernel-defs.gc @@ -169,6 +169,7 @@ (define-extern unload (function string none)) (define-extern reset-graph (function int int int int none)) +(define-extern __pc-set-levels (function (pointer string) none)) ;; PC stuff diff --git a/goal_src/jak2/kernel/gcommon.gc b/goal_src/jak2/kernel/gcommon.gc index 3933844d69..92c7470d40 100644 --- a/goal_src/jak2/kernel/gcommon.gc +++ b/goal_src/jak2/kernel/gcommon.gc @@ -1376,6 +1376,14 @@ `(none) ) +(defmacro sext32 (in) + `(sar (shl ,in 32) 32) + ) + +(defmacro .sra (result in sa) + `(set! ,result (sext32 (sar (logand #xffffffff (the-as int ,in)) ,sa))) + ) + ;;;;;;;;;;;;;;;;;;;;;;; ;; PC Port asm macros ;;;;;;;;;;;;;;;;;;;;;;; diff --git a/goal_src/jak2/kernel/gkernel-h.gc b/goal_src/jak2/kernel/gkernel-h.gc index 16938eecbe..0d95780d9b 100644 --- a/goal_src/jak2/kernel/gkernel-h.gc +++ b/goal_src/jak2/kernel/gkernel-h.gc @@ -722,3 +722,8 @@ "Access an object on the scratchpad." `(the-as ,type (&+ *fake-scratchpad-data* ,offset)) ) + +(defmacro scratchpad-ptr (type &key (offset 0)) + "Create a pointer to an object on the scratchpad." + `(the-as (pointer ,type) (&+ *fake-scratchpad-data* ,offset)) + ) \ No newline at end of file diff --git a/test/decompiler/reference/jak2/engine/gfx/background/tfrag-work_REF.gc b/test/decompiler/reference/jak2/engine/gfx/background/tfrag-work_REF.gc new file mode 100644 index 0000000000..8fc6970bd7 --- /dev/null +++ b/test/decompiler/reference/jak2/engine/gfx/background/tfrag-work_REF.gc @@ -0,0 +1,45 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *tfrag-work*, type tfrag-work +(define *tfrag-work* (new 'static 'tfrag-work + :base-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id ref)) + :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + :level-0-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id ref)) + :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + :common-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id ref)) + :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + :level-1-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id ref)) + :vif0 (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + :color-tmpl (new 'static 'dma-packet + :dma (new 'static 'dma-tag :id (dma-tag-id cnt)) + :vif0 (new 'static 'vif-tag :imm #x102 :cmd (vif-cmd stcycl)) + :vif1 (new 'static 'vif-tag :imm #xc000 :cmd (vif-cmd unpack-v4-8)) + ) + :max-fragment #xffff + ) + ) + +;; failed to figure out what this is: +(set! (-> *tfrag-work* color-ptr x) (+ 6144 #x70000000)) + +;; failed to figure out what this is: +(set! (-> *tfrag-work* color-ptr y) (+ 6144 #x70000000)) + +;; failed to figure out what this is: +(set! (-> *tfrag-work* color-ptr z) (+ 6144 #x70000000)) + +;; failed to figure out what this is: +(set! (-> *tfrag-work* color-ptr w) (+ 6144 #x70000000)) + + + + diff --git a/test/decompiler/reference/jak2/engine/gfx/hw/display-h_REF.gc b/test/decompiler/reference/jak2/engine/gfx/hw/display-h_REF.gc index beefb50a4a..a78e23ff08 100644 --- a/test/decompiler/reference/jak2/engine/gfx/hw/display-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/gfx/hw/display-h_REF.gc @@ -146,7 +146,7 @@ rn3 rn4 rn5 - rn6 + tfrag rn7 rn8 rn9 @@ -159,12 +159,12 @@ rn16 rn17 rn18 - rn19 + tfrag-trans rn20 rn21 rn22 rn23 - rn24 + tfrag-water rn25 rn26 rn27 @@ -180,7 +180,7 @@ rn3 rn4 rn5 - rn6 + tfrag rn7 rn8 rn9 @@ -193,12 +193,12 @@ rn16 rn17 rn18 - rn19 + tfrag-trans rn20 rn21 rn22 rn23 - rn24 + tfrag-water rn25 rn26 rn27 diff --git a/test/decompiler/reference/jak2/engine/gfx/merc/merc_REF.gc b/test/decompiler/reference/jak2/engine/gfx/merc/merc_REF.gc index 7017a4a1fc..9add29b2d1 100644 --- a/test/decompiler/reference/jak2/engine/gfx/merc/merc_REF.gc +++ b/test/decompiler/reference/jak2/engine/gfx/merc/merc_REF.gc @@ -89,7 +89,7 @@ (.por a3-3 a3-2 t0-0) (let ((f0-1 (fmax f0-0 f1-0))) (set! (-> a2-3 mask quad) a3-3) - (set! (-> a2-3 mask w) (the-as int f0-1)) + (set! (-> a2-3 dist) f0-1) ) ) ) diff --git a/test/decompiler/reference/jak2/engine/gfx/shrub/shrubbery_REF.gc b/test/decompiler/reference/jak2/engine/gfx/shrub/shrubbery_REF.gc index c8d28d014e..675963ec7f 100644 --- a/test/decompiler/reference/jak2/engine/gfx/shrub/shrubbery_REF.gc +++ b/test/decompiler/reference/jak2/engine/gfx/shrub/shrubbery_REF.gc @@ -166,12 +166,12 @@ (dotimes (a1-0 3) (set! (-> (the-as (pointer int32) (+ (+ (* a0-5 16) (* a1-0 4)) (the-as int *texture-masks*)))) (logior (-> (the-as (pointer int32) (+ (* a1-0 4) (the-as int *texture-masks*) (* a0-5 16))) 0) - (-> (the-as (inline-array texture-masks) (+ (* a1-0 4) (the-as int v1-3) (* a0-5 16))) 1 data 0 mask w) + (-> (the-as (pointer int32) (+ (* a1-0 4) (the-as int v1-3) (* a0-5 16))) 15) ) ) ) - (set! (-> *texture-masks* data a0-5 mask w) - (the-as int (fmax (-> *texture-masks* data a0-5 dist) (-> v1-3 masks data a0-5 dist))) + (set! (-> *texture-masks* data a0-5 dist) + (fmax (-> *texture-masks* data a0-5 dist) (-> v1-3 masks data a0-5 dist)) ) ) ) @@ -464,7 +464,7 @@ ;; ERROR: Unsupported inline assembly instruction kind - [mfpc a0, pcr1] (defun draw-drawable-tree-instance-shrub ((tree drawable-tree-instance-shrub) (level level)) (local-vars (a0-4 int) (a0-6 int) (a0-11 int) (a0-13 int)) - (set! (-> *instance-shrub-work* texture-dists) (-> level bsp shrub-mask-count)) + (set! (-> *instance-shrub-work* texture-dists) (the-as uint (-> level bsp shrub-closest))) (set! (-> *instance-shrub-work* near-last) (the-as uint 0)) (set! (-> *instance-shrub-work* near-next) (the-as uint 0)) (set! (-> *instance-shrub-work* near-count) (the-as uint 0)) @@ -773,7 +773,3 @@ ;; definition for function move-test-func ;; ERROR: function was not converted to expressions. Cannot decompile. - - - - diff --git a/test/decompiler/reference/jak2/engine/gfx/texture/texture_REF.gc b/test/decompiler/reference/jak2/engine/gfx/texture/texture_REF.gc index 258e09d19f..960060fd5a 100644 --- a/test/decompiler/reference/jak2/engine/gfx/texture/texture_REF.gc +++ b/test/decompiler/reference/jak2/engine/gfx/texture/texture_REF.gc @@ -2181,11 +2181,8 @@ ;; definition for function hack-texture (defun hack-texture ((arg0 texture)) (set! (-> arg0 uv-dist) 1000000.0) - (set! (-> arg0 masks data 0 mask w) (the-as int (+ 40960000.0 (-> arg0 masks data 0 dist)))) - (let ((f0-4 (+ 40960000.0 (-> arg0 masks data 1 dist)))) - (set! (-> arg0 masks data 1 mask w) (the-as int f0-4)) - f0-4 - ) + (set! (-> arg0 masks data 0 dist) (+ 40960000.0 (-> arg0 masks data 0 dist))) + (set! (-> arg0 masks data 1 dist) (+ 40960000.0 (-> arg0 masks data 1 dist))) ) ;; definition for function adgif-shader-login diff --git a/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-h_REF.gc b/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-h_REF.gc index 894ae6a189..6e8c20671f 100644 --- a/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-h_REF.gc @@ -80,6 +80,7 @@ (dma-base uint32 :offset 36) (dma-level-1 uint32 :offset 40) (dma-qwc uint8 4 :offset 44) + (dma-u32 uint32 :offset 44) (shader (inline-array adgif-shader) :offset 48) (num-shaders uint8 :offset 52) (num-base-colors uint8 :offset 53) @@ -490,7 +491,3 @@ ;; failed to figure out what this is: 0 - - - - diff --git a/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-near_REF.gc b/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-near_REF.gc new file mode 100644 index 0000000000..7e32a619d8 --- /dev/null +++ b/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-near_REF.gc @@ -0,0 +1,76 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol tnear-vu1-block, type vu-function +(define tnear-vu1-block (new 'static 'vu-function :length #x38b :qlength #x1c6)) + +;; definition (debug) for function tfrag-details +;; WARN: Return type mismatch symbol vs none. +(defun-debug tfrag-details ((arg0 tfragment)) + (format 0 "id = ~d~%" (-> arg0 id)) + (format 0 "common:~%") + (let ((s5-0 (-> arg0 dma-qwc 0)) + (s4-0 (-> arg0 dma-common)) + ) + (format 0 "qwc = ~d, ref = ~x~%" s5-0 s4-0) + (disasm-vif-tag (the-as (pointer vif-tag) s4-0) (the-as int (* s5-0 4)) (the-as symbol 0) #t) + ) + (format 0 "base:~%") + (let ((s5-1 (-> arg0 dma-qwc 1)) + (s4-1 (-> arg0 dma-base)) + ) + (format 0 "qwc = ~d, ref = ~x~%" s5-1 s4-1) + (disasm-vif-tag (the-as (pointer vif-tag) s4-1) (the-as int (* s5-1 4)) (the-as symbol 0) #t) + ) + (format 0 "level-0:~%") + (let ((s5-2 (-> arg0 dma-qwc 3)) + (s4-2 (-> arg0 dma-u32)) + ) + (format 0 "qwc = ~d, ref = ~x~%" s5-2 s4-2) + (disasm-vif-tag (the-as (pointer vif-tag) s4-2) (the-as int (* s5-2 4)) (the-as symbol 0) #t) + ) + (format 0 "level-1:~%") + (let ((s5-3 (-> arg0 dma-qwc 2)) + (gp-1 (-> arg0 dma-level-1)) + ) + (format 0 "qwc = ~d, ref = ~x~%" s5-3 gp-1) + (disasm-vif-tag (the-as (pointer vif-tag) gp-1) (the-as int (* s5-3 4)) (the-as symbol 0) #t) + ) + (none) + ) + +;; definition (debug) for function clip-restore +;; INFO: Used lq/sq +;; WARN: Return type mismatch vector vs none. +(defun-debug clip-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) 92648.22) + (set! (-> a0-0 y) 238025.03) + (set! (-> a0-0 z) 199836.31) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) -0.9283) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) 0.3716) + (set! (-> a1-0 vector 0 w) 0.0) + (set! (-> a1-0 vector 1 x) -0.2257) + (set! (-> a1-0 vector 1 y) 0.7945) + (set! (-> a1-0 vector 1 z) -0.5637) + (set! (-> a1-0 vector 1 w) 0.0) + (set! (-> a1-0 vector 2 x) -0.2952) + (set! (-> a1-0 vector 2 y) -0.6072) + (set! (-> a1-0 vector 2 z) -0.7375) + (set! (-> a1-0 vector 2 w) 0.0) + (set! (-> a1-0 trans x) 0.0) + (set! (-> a1-0 trans y) 0.0) + (set! (-> a1-0 trans z) 0.0) + (set! (-> a1-0 trans w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + (none) + ) + + + + diff --git a/test/decompiler/reference/jak2/engine/level/bsp-h_REF.gc b/test/decompiler/reference/jak2/engine/level/bsp-h_REF.gc index fb796aa537..4918118ecc 100644 --- a/test/decompiler/reference/jak2/engine/level/bsp-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/level/bsp-h_REF.gc @@ -69,15 +69,20 @@ (region-trees (array drawable-tree-region-prim) :offset-assert 188) (region-array region-array :offset-assert 192) (collide-hash collide-hash :offset-assert 196) + (wind-array-length int32 :offset 204) (region-tree drawable-tree-region-prim :offset 252) (tfrag-masks texture-masks-array :offset-assert 256) - (tfrag-mask-count uint32 :offset-assert 260) + (tfrag-closest (pointer float) :offset-assert 260) + (tfrag-mask-count uint32 :offset 260) (shrub-masks texture-masks-array :offset-assert 264) - (shrub-mask-count uint32 :offset-assert 268) + (shrub-closest (pointer float) :offset-assert 268) + (shrub-mask-count uint32 :offset 268) (alpha-masks texture-masks-array :offset-assert 272) - (alpha-mask-count uint32 :offset-assert 276) + (alpha-closest (pointer float) :offset-assert 276) + (alpha-mask-count uint32 :offset 276) (water-masks texture-masks-array :offset-assert 280) - (water-mask-count uint32 :offset-assert 284) + (water-closest (pointer float) :offset-assert 284) + (water-mask-count uint32 :offset 284) (bsp-scale vector :inline :offset-assert 288) (bsp-offset vector :inline :offset-assert 304) (unk-data uint32 18 :offset 180) diff --git a/test/decompiler/reference/jak2/engine/level/bsp_REF.gc b/test/decompiler/reference/jak2/engine/level/bsp_REF.gc index 9e9ce29a9b..081658b6eb 100644 --- a/test/decompiler/reference/jak2/engine/level/bsp_REF.gc +++ b/test/decompiler/reference/jak2/engine/level/bsp_REF.gc @@ -609,12 +609,12 @@ ;; WARN: Return type mismatch int vs none. (defun build-masks ((arg0 bsp-header)) (let ((v1-0 (-> arg0 drawable-trees)) - (s2-0 (-> arg0 tfrag-mask-count)) - (s3-0 (-> arg0 shrub-mask-count)) - (s4-0 (-> arg0 alpha-mask-count)) - (gp-0 (-> arg0 water-mask-count)) + (s2-0 (-> arg0 tfrag-closest)) + (s3-0 (-> arg0 shrub-closest)) + (s4-0 (-> arg0 alpha-closest)) + (gp-0 (-> arg0 water-closest)) ) - (when (zero? (+ s2-0 s3-0 s4-0 gp-0)) + (when (zero? (&+ (+ (&+ s2-0 s3-0) (the-as int s4-0)) gp-0)) (dotimes (a0-5 (-> v1-0 length)) (let ((a1-2 (-> v1-0 trees a0-5))) (cond @@ -624,8 +624,8 @@ (a2-6 (-> (the-as drawable-inline-array-tfrag a2-5) data)) ) (dotimes (a3-1 a1-4) - (set! (-> a2-6 0 texture-masks-index) s2-0) - (+! s2-0 1) + (set! (-> a2-6 0 texture-masks-index) (the-as uint s2-0)) + (&+! s2-0 1) (set! a2-6 (the-as (inline-array tfragment) (-> a2-6 1))) ) ) @@ -638,8 +638,8 @@ (a2-14 (-> (the-as drawable-inline-array-tfrag a2-13) data)) ) (dotimes (a3-3 a1-7) - (set! (-> a2-14 0 texture-masks-index) s4-0) - (+! s4-0 1) + (set! (-> a2-14 0 texture-masks-index) (the-as uint s4-0)) + (&+! s4-0 1) (set! a2-14 (the-as (inline-array tfragment) (-> a2-14 1))) ) ) @@ -652,8 +652,8 @@ (a2-22 (-> (the-as drawable-inline-array-tfrag a2-21) data)) ) (dotimes (a3-5 a1-10) - (set! (-> a2-22 0 texture-masks-index) gp-0) - (+! gp-0 1) + (set! (-> a2-22 0 texture-masks-index) (the-as uint gp-0)) + (&+! gp-0 1) (set! a2-22 (the-as (inline-array tfragment) (-> a2-22 1))) ) ) @@ -665,16 +665,16 @@ (dotimes (a3-7 a2-26) (cond ((logtest? (-> a1-13 array-data a3-7 flags) (prototype-flags tpage-water)) - (set! (-> a1-13 array-data a3-7 texture-masks-index) gp-0) - (+! gp-0 1) + (set! (-> a1-13 array-data a3-7 texture-masks-index) (the-as uint gp-0)) + (&+! gp-0 1) ) ((logtest? (-> a1-13 array-data a3-7 flags) (prototype-flags tpage-alpha)) - (set! (-> a1-13 array-data a3-7 texture-masks-index) s4-0) - (+! s4-0 1) + (set! (-> a1-13 array-data a3-7 texture-masks-index) (the-as uint s4-0)) + (&+! s4-0 1) ) (else - (set! (-> a1-13 array-data a3-7 texture-masks-index) s2-0) - (+! s2-0 1) + (set! (-> a1-13 array-data a3-7 texture-masks-index) (the-as uint s2-0)) + (&+! s2-0 1) ) ) ) @@ -686,8 +686,8 @@ (a2-31 (-> a2-30 data)) ) (dotimes (a3-9 a1-16) - (set! (-> a2-31 0 texture-masks-index) s3-0) - (+! s3-0 1) + (set! (-> a2-31 0 texture-masks-index) (the-as uint s3-0)) + (&+! s3-0 1) (set! a2-31 (the-as (inline-array prototype-bucket-shrub) (-> a2-31 1))) ) ) @@ -698,7 +698,7 @@ ) (when (nonzero? s2-0) (set! (-> arg0 tfrag-masks) (new 'loading-level 'texture-masks-array (the-as int s2-0))) - (set! (-> arg0 tfrag-mask-count) (the-as uint (malloc 'loading-level (the-as int (* s2-0 4))))) + (set! (-> arg0 tfrag-closest) (the-as (pointer float) (malloc 'loading-level (the-as int (* s2-0 4))))) (let ((v1-5 (-> arg0 tfrag-masks))) (dotimes (a0-8 (the-as int s2-0)) (let ((a1-24 (-> v1-5 data a0-8))) @@ -711,7 +711,7 @@ ) (when (nonzero? s3-0) (set! (-> arg0 shrub-masks) (new 'loading-level 'texture-masks-array (the-as int s3-0))) - (set! (-> arg0 shrub-mask-count) (the-as uint (malloc 'loading-level (the-as int (* s3-0 4))))) + (set! (-> arg0 shrub-closest) (the-as (pointer float) (malloc 'loading-level (the-as int (* s3-0 4))))) (let ((v1-10 (-> arg0 shrub-masks))) (dotimes (a0-11 (the-as int s3-0)) (let ((a1-32 (-> v1-10 data a0-11))) @@ -724,7 +724,7 @@ ) (when (nonzero? s4-0) (set! (-> arg0 alpha-masks) (new 'loading-level 'texture-masks-array (the-as int s4-0))) - (set! (-> arg0 alpha-mask-count) (the-as uint (malloc 'loading-level (the-as int (* s4-0 4))))) + (set! (-> arg0 alpha-closest) (the-as (pointer float) (malloc 'loading-level (the-as int (* s4-0 4))))) (let ((v1-15 (-> arg0 alpha-masks))) (dotimes (a0-14 (the-as int s4-0)) (let ((a1-40 (-> v1-15 data a0-14))) @@ -737,7 +737,7 @@ ) (when (nonzero? gp-0) (set! (-> arg0 water-masks) (new 'loading-level 'texture-masks-array (the-as int gp-0))) - (set! (-> arg0 water-mask-count) (the-as uint (malloc 'loading-level (the-as int (* gp-0 4))))) + (set! (-> arg0 water-closest) (the-as (pointer float) (malloc 'loading-level (the-as int (* gp-0 4))))) (let ((v1-20 (-> arg0 water-masks))) (dotimes (a0-17 (the-as int gp-0)) (let ((a1-48 (-> v1-20 data a0-17))) diff --git a/test/decompiler/reference/jak2/engine/level/level-h_REF.gc b/test/decompiler/reference/jak2/engine/level/level-h_REF.gc index 4e2bbe387b..7c035b2211 100644 --- a/test/decompiler/reference/jak2/engine/level/level-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/level/level-h_REF.gc @@ -455,6 +455,7 @@ (water-masks texture-masks-array :offset-assert 5064) (water-dists pointer :offset-assert 5068) (tfrag-last-calls int32 6 :offset-assert 5072) + (tfrag-last-calls-u32 uint32 6 :offset 5072) (texture-anim-array texture-anim-array 10 :offset-assert 5096) (light-hash light-hash :offset-assert 5136) (draw-priority float :offset-assert 5140) diff --git a/test/decompiler/reference/jak2/engine/util/profile_REF.gc b/test/decompiler/reference/jak2/engine/util/profile_REF.gc index ac824b63e9..bf574715f6 100644 --- a/test/decompiler/reference/jak2/engine/util/profile_REF.gc +++ b/test/decompiler/reference/jak2/engine/util/profile_REF.gc @@ -155,42 +155,42 @@ ;; definition for function profile-tfrag-test (defun profile-tfrag-test ((arg0 bucket-id)) - (or (= arg0 (bucket-id bucket-8)) - (= arg0 (bucket-id bucket-19)) - (= arg0 (bucket-id bucket-30)) - (= arg0 (bucket-id bucket-41)) - (= arg0 (bucket-id bucket-52)) - (= arg0 (bucket-id bucket-63)) - (= arg0 (bucket-id bucket-11)) - (= arg0 (bucket-id bucket-22)) - (= arg0 (bucket-id bucket-33)) - (= arg0 (bucket-id bucket-44)) - (= arg0 (bucket-id bucket-55)) - (= arg0 (bucket-id bucket-66)) - (= arg0 (bucket-id bucket-128)) - (= arg0 (bucket-id bucket-138)) - (= arg0 (bucket-id bucket-148)) - (= arg0 (bucket-id bucket-158)) - (= arg0 (bucket-id bucket-168)) - (= arg0 (bucket-id bucket-178)) - (= arg0 (bucket-id bucket-255)) - (= arg0 (bucket-id bucket-264)) - (= arg0 (bucket-id bucket-273)) - (= arg0 (bucket-id bucket-282)) - (= arg0 (bucket-id bucket-291)) - (= arg0 (bucket-id bucket-300)) - (= arg0 (bucket-id bucket-134)) - (= arg0 (bucket-id bucket-144)) - (= arg0 (bucket-id bucket-154)) - (= arg0 (bucket-id bucket-164)) - (= arg0 (bucket-id bucket-174)) - (= arg0 (bucket-id bucket-184)) - (= arg0 (bucket-id bucket-259)) - (= arg0 (bucket-id bucket-268)) - (= arg0 (bucket-id bucket-277)) - (= arg0 (bucket-id bucket-286)) - (= arg0 (bucket-id bucket-295)) - (= arg0 (bucket-id bucket-304)) + (or (= arg0 (bucket-id tfrag-l0-tfrag)) + (= arg0 (bucket-id tfrag-l1-tfrag)) + (= arg0 (bucket-id tfrag-l2-tfrag)) + (= arg0 (bucket-id tfrag-l3-tfrag)) + (= arg0 (bucket-id tfrag-l4-tfrag)) + (= arg0 (bucket-id tfrag-l5-tfrag)) + (= arg0 (bucket-id tfrag-s-l0-tfrag)) + (= arg0 (bucket-id tfrag-s-l1-tfrag)) + (= arg0 (bucket-id tfrag-s-l2-tfrag)) + (= arg0 (bucket-id tfrag-s-l3-tfrag)) + (= arg0 (bucket-id tfrag-s-l4-tfrag)) + (= arg0 (bucket-id tfrag-s-l5-tfrag)) + (= arg0 (bucket-id tfrag-t-l0-alpha)) + (= arg0 (bucket-id tfrag-t-l1-alpha)) + (= arg0 (bucket-id tfrag-t-l2-alpha)) + (= arg0 (bucket-id tfrag-t-l3-alpha)) + (= arg0 (bucket-id tfrag-t-l4-alpha)) + (= arg0 (bucket-id tfrag-t-l5-alpha)) + (= arg0 (bucket-id tfrag-w-l0-water)) + (= arg0 (bucket-id tfrag-w-l1-water)) + (= arg0 (bucket-id tfrag-w-l2-water)) + (= arg0 (bucket-id tfrag-w-l3-water)) + (= arg0 (bucket-id tfrag-w-l4-water)) + (= arg0 (bucket-id tfrag-w-l5-water)) + (= arg0 (bucket-id tfrag-st-l0-alpha)) + (= arg0 (bucket-id tfrag-st-l1-alpha)) + (= arg0 (bucket-id tfrag-st-l2-alpha)) + (= arg0 (bucket-id tfrag-st-l3-alpha)) + (= arg0 (bucket-id tfrag-st-l4-alpha)) + (= arg0 (bucket-id tfrag-st-l5-alpha)) + (= arg0 (bucket-id tfrag-ws-l0-water)) + (= arg0 (bucket-id tfrag-ws-l1-water)) + (= arg0 (bucket-id tfrag-ws-l2-water)) + (= arg0 (bucket-id tfrag-ws-l3-water)) + (= arg0 (bucket-id tfrag-ws-l4-water)) + (= arg0 (bucket-id tfrag-ws-l5-water)) ) ) diff --git a/test/offline/config/jak2/config.jsonc b/test/offline/config/jak2/config.jsonc index 159837e933..7b69ccdee9 100644 --- a/test/offline/config/jak2/config.jsonc +++ b/test/offline/config/jak2/config.jsonc @@ -129,6 +129,7 @@ "(method 10 mysql-nav-graph)", "bsp-camera-asm", + "build-masks", "i-hopefully-will-never-exist-dont-add-anything-after-me-please" ],