mirror/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project synced 2026-09-09 20:21:28 -04:00
Code Issues Packages Projects Releases Wiki Activity

clean up generic-effect

Browse Source
This commit is contained in:
water111
2026-08-23 22:56:19 -07:00
parent 717354893b
commit a1c2f5114c
10 changed files with 580 additions and 6817 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game/CMakeLists.txt
-2
View File
@@ -162,8 +162,6 @@ set(RUNTIME_SOURCE
mips2c/jak1_functions/collide_mesh.cpp
mips2c/jak1_functions/collide_probe.cpp
mips2c/jak1_functions/draw_string.cpp
mips2c/jak1_functions/generic_effect.cpp
mips2c/jak1_functions/generic_effect2.cpp
mips2c/jak1_functions/generic_merc.cpp
mips2c/jak1_functions/generic_tie.cpp
mips2c/jak1_functions/merc_blend_shape.cpp
game/mips2c/jak1_functions/generic_effect.cpp
-1954
View File
File diff suppressed because it is too large Load Diff
game/mips2c/jak1_functions/generic_effect2.cpp
-127
View File
@@ -1,127 +0,0 @@
//--------------------------MIPS2C---------------------
#include "game/kernel/jak1/kscheme.h"
#include "game/mips2c/mips2c_private.h"
using namespace jak1;
namespace Mips2C::jak1 {
// clang-format off
void vcallms48(ExecutionContext* c) {
// nop | mulx.xyzw vf13, vf09, vf31
c->vfs[vf13].vf.mul(Mask::xyzw, c->vf_src(vf09).vf, c->vf_src(vf31).vf.x());
// nop | subw.z vf21, vf21, vf00
c->vfs[vf21].vf.sub(Mask::z, c->vf_src(vf21).vf, c->vf_src(vf00).vf.w());
// nop | addy.x vf29, vf29, vf29
c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.y());
// nop | mulx.xyz vf08, vf08, vf30
c->vfs[vf08].vf.mul(Mask::xyz, c->vf_src(vf08).vf, c->vf_src(vf30).vf.x());
// nop | addw.xy vf05, vf05, vf31
c->vfs[vf05].vf.add(Mask::xy, c->vf_src(vf05).vf, c->vf_src(vf31).vf.w());
// nop | mul.xyz vf30, vf21, vf13
c->vfs[vf30].vf.mul(Mask::xyz, c->vf_src(vf21).vf, c->vf_src(vf13).vf);
// nop | addz.x vf29, vf29, vf29
c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.z());
// nop | add.xyz vf08, vf08, vf16
c->vfs[vf08].vf.add(Mask::xyz, c->vf_src(vf08).vf, c->vf_src(vf16).vf);
// move.xyzw vf28, vf27 | ftoi12.xy vf17, vf05
c->vfs[vf17].vf.ftoi12(Mask::xy, c->vf_src(vf05).vf); c->vfs[vf28].vf.move(Mask::xyzw, c->vf_src(vf27).vf);
// move.xyzw vf02, vf22 | addy.x vf30, vf30, vf30
c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.y()); c->vfs[vf02].vf.move(Mask::xyzw, c->vf_src(vf22).vf);
// rsqrt Q, vf31.z, vf29.x | mul.xyz vf06, vf06, Q
c->vfs[vf06].vf.mul(Mask::xyz, c->vf_src(vf06).vf, c->Q); c->Q = c->vf_src(vf31).vf.z() / std::sqrt(c->vf_src(vf29).vf.x());
// nop | mul.xyz vf29, vf08, vf08
c->vfs[vf29].vf.mul(Mask::xyz, c->vf_src(vf08).vf, c->vf_src(vf08).vf);
// nop | mulx.xyz vf01, vf21, vf28
c->vfs[vf01].vf.mul(Mask::xyz, c->vf_src(vf21).vf, c->vf_src(vf28).vf.x());
// nop | addz.x vf30, vf30, vf30
c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.z());
// nop | mulx.xyzw vf14, vf10, vf31
c->vfs[vf14].vf.mul(Mask::xyzw, c->vf_src(vf10).vf, c->vf_src(vf31).vf.x());
// nop | subw.z vf02, vf02, vf00
c->vfs[vf02].vf.sub(Mask::z, c->vf_src(vf02).vf, c->vf_src(vf00).vf.w());
// nop | addy.x vf29, vf29, vf29
c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.y());
// nop | mulx.xyz vf01, vf01, vf30
c->vfs[vf01].vf.mul(Mask::xyz, c->vf_src(vf01).vf, c->vf_src(vf30).vf.x());
// nop | addw.xy vf06, vf06, vf31
c->vfs[vf06].vf.add(Mask::xy, c->vf_src(vf06).vf, c->vf_src(vf31).vf.w());
// nop | mul.xyz vf30, vf02, vf14
c->vfs[vf30].vf.mul(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf14).vf);
// nop | addz.x vf29, vf29, vf29
c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.z());
// nop | add.xyz vf01, vf01, vf13
c->vfs[vf01].vf.add(Mask::xyz, c->vf_src(vf01).vf, c->vf_src(vf13).vf);
// nop | ftoi12.xy vf18, vf06
c->vfs[vf18].vf.ftoi12(Mask::xy, c->vf_src(vf06).vf);
// nop | addy.x vf30, vf30, vf30
c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.y());
// rsqrt Q, vf31.z, vf29.x | mul.xyz vf07, vf07, Q
c->vfs[vf07].vf.mul(Mask::xyz, c->vf_src(vf07).vf, c->Q); c->Q = c->vf_src(vf31).vf.z() / std::sqrt(c->vf_src(vf29).vf.x());
// move.xyzw vf03, vf23 | mul.xyz vf29, vf01, vf01
c->vfs[vf29].vf.mul(Mask::xyz, c->vf_src(vf01).vf, c->vf_src(vf01).vf); c->vfs[vf03].vf.move(Mask::xyzw, c->vf_src(vf23).vf);
// nop | muly.xyz vf02, vf02, vf28
c->vfs[vf02].vf.mul(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf28).vf.y());
// nop | addz.x vf30, vf30, vf30
c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.z());
// nop | mulx.xyzw vf15, vf11, vf31
c->vfs[vf15].vf.mul(Mask::xyzw, c->vf_src(vf11).vf, c->vf_src(vf31).vf.x());
// nop | subw.z vf03, vf03, vf00
c->vfs[vf03].vf.sub(Mask::z, c->vf_src(vf03).vf, c->vf_src(vf00).vf.w());
// nop | addy.x vf29, vf29, vf29
c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.y());
// nop | mulx.xyz vf02, vf02, vf30
c->vfs[vf02].vf.mul(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf30).vf.x());
// nop | addw.xy vf07, vf07, vf31
c->vfs[vf07].vf.add(Mask::xy, c->vf_src(vf07).vf, c->vf_src(vf31).vf.w());
// nop | mul.xyz vf30, vf03, vf15
c->vfs[vf30].vf.mul(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf15).vf);
// nop | addz.x vf29, vf29, vf29
c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.z());
// nop | add.xyz vf02, vf02, vf14
c->vfs[vf02].vf.add(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf14).vf);
// nop | ftoi12.xy vf19, vf07
c->vfs[vf19].vf.ftoi12(Mask::xy, c->vf_src(vf07).vf);
// nop | addy.x vf30, vf30, vf30
c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.y());
// rsqrt Q, vf31.z, vf29.x | mul.xyz vf08, vf08, Q
c->vfs[vf08].vf.mul(Mask::xyz, c->vf_src(vf08).vf, c->Q); c->Q = c->vf_src(vf31).vf.z() / std::sqrt(c->vf_src(vf29).vf.x());
// move.xyzw vf04, vf24 | mul.xyz vf29, vf02, vf02
c->vfs[vf29].vf.mul(Mask::xyz, c->vf_src(vf02).vf, c->vf_src(vf02).vf); c->vfs[vf04].vf.move(Mask::xyzw, c->vf_src(vf24).vf);
// nop | mulz.xyz vf03, vf03, vf28
c->vfs[vf03].vf.mul(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf28).vf.z());
// nop | addz.x vf30, vf30, vf30
c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.z());
// nop | mulx.xyzw vf16, vf12, vf31
c->vfs[vf16].vf.mul(Mask::xyzw, c->vf_src(vf12).vf, c->vf_src(vf31).vf.x());
// nop | subw.z vf04, vf04, vf00
c->vfs[vf04].vf.sub(Mask::z, c->vf_src(vf04).vf, c->vf_src(vf00).vf.w());
// nop | addy.x vf29, vf29, vf29
c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.y());
// nop | mulx.xyz vf03, vf03, vf30
c->vfs[vf03].vf.mul(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf30).vf.x());
// nop | addw.xy vf08, vf08, vf31
c->vfs[vf08].vf.add(Mask::xy, c->vf_src(vf08).vf, c->vf_src(vf31).vf.w());
// nop | mul.xyz vf30, vf04, vf16
c->vfs[vf30].vf.mul(Mask::xyz, c->vf_src(vf04).vf, c->vf_src(vf16).vf);
// nop | addz.x vf29, vf29, vf29
c->vfs[vf29].vf.add(Mask::x, c->vf_src(vf29).vf, c->vf_src(vf29).vf.z());
// nop | add.xyz vf03, vf03, vf15
c->vfs[vf03].vf.add(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf15).vf);
// nop | ftoi12.xy vf20, vf08
c->vfs[vf20].vf.ftoi12(Mask::xy, c->vf_src(vf08).vf);
// nop | addy.x vf30, vf30, vf30
c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.y());
// rsqrt Q, vf31.z, vf29.x | mul.xyz vf05, vf01, Q
c->vfs[vf05].vf.mul(Mask::xyz, c->vf_src(vf01).vf, c->Q); c->Q = c->vf_src(vf31).vf.z() / std::sqrt(c->vf_src(vf29).vf.x());
// move.xyzw vf06, vf02 | mul.xyz vf29, vf03, vf03
c->vfs[vf29].vf.mul(Mask::xyz, c->vf_src(vf03).vf, c->vf_src(vf03).vf); c->vfs[vf06].vf.move(Mask::xyzw, c->vf_src(vf02).vf);
// move.xyzw vf07, vf03 | mulw.xyz vf08, vf04, vf28 :e
c->vfs[vf08].vf.mul(Mask::xyz, c->vf_src(vf04).vf, c->vf_src(vf28).vf.w()); c->vfs[vf07].vf.move(Mask::xyzw, c->vf_src(vf03).vf);
// nop | addz.x vf30, vf30, vf30
c->vfs[vf30].vf.add(Mask::x, c->vf_src(vf30).vf, c->vf_src(vf30).vf.z());
}
} // namespace Mips2C
game/mips2c/jak1_functions/generic_merc.cpp
+29 -31
View File
@@ -3,21 +3,9 @@
using namespace jak1;
namespace Mips2C::jak1 {
namespace generic_prepare_dma_single {
u64 execute(void* ctxt);
}
namespace generic_prepare_dma_double {
u64 execute(void* ctxt);
}
namespace mercneric_convert {
u64 execute(void* ctxt);
}
namespace generic_light_proc {
u64 execute(void* ctxt);
}
namespace generic_envmap_proc {
u64 execute(void* ctxt);
}
namespace high_speed_reject {
u64 execute(void* ctxt);
}
@@ -292,8 +280,24 @@ struct Cache {
void* merc_globals; // *merc-globals*
void* merc_death_spawn; // merc-death-spawn
void* vector_matrix; // vector-matrix*!
void* generic_effect_stats; // *generic-effect-stats*
void* note_prepare_dma_single; // generic-note-prepare-dma-single
void* note_prepare_dma_double; // generic-note-prepare-dma-double
void* note_light_proc; // generic-note-light-proc
void* note_envmap_proc; // generic-note-envmap-proc
} cache;
static u32 symbol_value(void* symbol) {
return *reinterpret_cast<u32*>(symbol);
}
static void call_generic_effect(ExecutionContext* c, u32 address, void* note_symbol) {
if (symbol_value(cache.generic_effect_stats) != c->gprs[s7].du32[0]) {
c->jalr(symbol_value(note_symbol));
}
c->jalr(address);
}
u64 execute(void* ctxt) {
auto* c = (ExecutionContext*)ctxt;
bool bc = false;
@@ -1033,20 +1037,17 @@ u64 execute(void* ctxt) {
c->lwu(t9, 7336, v1); // lwu t9, 7336(v1)
call_addr = c->gprs[t9].du32[0]; // function call:
c->sll(v0, ra, 0); // sll v0, ra, 0
// c->jalr(call_addr); // jalr ra, t9
generic_prepare_dma_double::execute(c);
call_generic_effect(c, call_addr, cache.note_prepare_dma_double);
get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
c->lwu(t9, 7340, v1); // lwu t9, 7340(v1)
call_addr = c->gprs[t9].du32[0]; // function call:
c->sll(v0, ra, 0); // sll v0, ra, 0
// c->jalr(call_addr); // jalr ra, t9
generic_light_proc::execute(c);
call_generic_effect(c, call_addr, cache.note_light_proc);
get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
c->lwu(t9, 7344, v1); // lwu t9, 7344(v1)
call_addr = c->gprs[t9].du32[0]; // function call:
c->sll(v0, ra, 0); // sll v0, ra, 0
// c->jalr(call_addr); // jalr ra, t9
generic_envmap_proc::execute(c);
call_generic_effect(c, call_addr, cache.note_envmap_proc);
c->lw(v1, 40, at); // lw v1, 40(at)
c->lw(a0, 56, at); // lw a0, 56(at)
c->mov64(a3, v1); // or a3, v1, r0
@@ -1142,20 +1143,17 @@ u64 execute(void* ctxt) {
c->lwu(t9, 7336, v1); // lwu t9, 7336(v1)
call_addr = c->gprs[t9].du32[0]; // function call:
c->sll(v0, ra, 0); // sll v0, ra, 0
// c->jalr(call_addr); // jalr ra, t9
generic_prepare_dma_double::execute(c);
call_generic_effect(c, call_addr, cache.note_prepare_dma_double);
get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
c->lwu(t9, 7340, v1); // lwu t9, 7340(v1)
call_addr = c->gprs[t9].du32[0]; // function call:
c->sll(v0, ra, 0); // sll v0, ra, 0
// c->jalr(call_addr); // jalr ra, t9
generic_light_proc::execute(c);
call_generic_effect(c, call_addr, cache.note_light_proc);
get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
c->lwu(t9, 7344, v1); // lwu t9, 7344(v1)
call_addr = c->gprs[t9].du32[0]; // function call:
c->sll(v0, ra, 0); // sll v0, ra, 0
// c->jalr(call_addr); // jalr ra, t9
generic_envmap_proc::execute(c);
call_generic_effect(c, call_addr, cache.note_envmap_proc);
c->lw(v1, 40, at); // lw v1, 40(at)
c->lw(a0, 56, at); // lw a0, 56(at)
c->mov64(a3, v1); // or a3, v1, r0
@@ -1231,14 +1229,12 @@ u64 execute(void* ctxt) {
c->lwu(t9, 7332, v1); // lwu t9, 7332(v1)
call_addr = c->gprs[t9].du32[0]; // function call:
c->sll(v0, ra, 0); // sll v0, ra, 0
// c->jalr(call_addr); // jalr ra, t9
generic_prepare_dma_single::execute(c);
call_generic_effect(c, call_addr, cache.note_prepare_dma_single);
get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
c->lwu(t9, 7340, v1); // lwu t9, 7340(v1)
call_addr = c->gprs[t9].du32[0]; // function call:
c->sll(v0, ra, 0); // sll v0, ra, 0
// c->jalr(call_addr); // jalr ra, t9
generic_light_proc::execute(c);
call_generic_effect(c, call_addr, cache.note_light_proc);
c->lw(v1, 40, at); // lw v1, 40(at)
c->lw(a0, 56, at); // lw a0, 56(at)
c->mov64(a3, v1); // or a3, v1, r0
@@ -1343,6 +1339,11 @@ void link() {
cache.merc_globals = intern_from_c("*merc-globals*").c();
cache.merc_death_spawn = intern_from_c("merc-death-spawn").c();
cache.vector_matrix = intern_from_c("vector-matrix*!").c();
cache.generic_effect_stats = intern_from_c("*generic-effect-stats*").c();
cache.note_prepare_dma_single = intern_from_c("generic-note-prepare-dma-single").c();
cache.note_prepare_dma_double = intern_from_c("generic-note-prepare-dma-double").c();
cache.note_light_proc = intern_from_c("generic-note-light-proc").c();
cache.note_envmap_proc = intern_from_c("generic-note-envmap-proc").c();
gLinkedFunctionTable.reg("generic-merc-execute-asm", execute, 1024);
}
@@ -3826,6 +3827,3 @@ void link() {
} // namespace high_speed_reject
} // namespace Mips2C
game/mips2c/jak1_functions/generic_tie.cpp
+1 -1
View File
@@ -2077,7 +2077,7 @@ u64 execute(void* ctxt) {
call_addr = c->gprs[v1].du32[0]; // function call:
// Unknown instr: sllv v0, ra, r0
// c->jalr(call_addr); // jalr ra, v1
generic_prepare_dma_double::execute(c);
// generic_prepare_dma_double::execute(c);
c->lw(v1, 752, at); // lw v1, 752(at)
call_addr = c->gprs[v1].du32[0]; // function call:
// Unknown instr: sllv v0, ra, r0
game/mips2c/mips2c_table.cpp
-7
View File
@@ -76,11 +76,7 @@ namespace setup_blerc_chains_for_one_fragment { extern void link(); }
namespace generic_merc_init_asm { extern void link(); }
namespace generic_merc_execute_asm { extern void link(); }
namespace mercneric_convert { extern void link(); }
namespace generic_prepare_dma_double { extern void link(); }
namespace generic_light_proc { extern void link(); }
namespace generic_envmap_proc { extern void link(); }
namespace high_speed_reject { extern void link(); }
namespace generic_prepare_dma_single { extern void link(); }
namespace init_ocean_far_regs { extern void link(); }
namespace render_ocean_quad { extern void link(); }
namespace draw_large_polygon_ocean { extern void link(); }
@@ -428,9 +424,6 @@ PerGameVersion<std::unordered_map<std::string, std::vector<void (*)()>>> gMips2C
{"generic-merc",
{jak1::generic_merc_init_asm::link, jak1::generic_merc_execute_asm::link,
jak1::mercneric_convert::link, jak1::high_speed_reject::link}},
{"generic-effect",
{jak1::generic_prepare_dma_double::link, jak1::generic_light_proc::link,
jak1::generic_envmap_proc::link, jak1::generic_prepare_dma_single::link}},
{"ocean",
{jak1::init_ocean_far_regs::link, jak1::render_ocean_quad::link,
jak1::draw_large_polygon_ocean::link}},
goal_src/jak1/engine/gfx/generic/generic-effect.gc
+516 -4688
View File
File diff suppressed because it is too large Load Diff
goal_src/jak1/engine/gfx/generic/generic-h.gc
+3 -2
View File
@@ -124,7 +124,8 @@
;; An indexed vertex reference and whether it suppresses the strip kick.
;; One per draw point; together they are the drawing order.
((index uint8)
(no-kick uint8)))
(no-kick uint8))
:pack-me)
;; Pointers installed at the front of a GSF buffer before the work area is built. The converter lays
;; the three arrays out back to back and publishes them here, so neither the effect processors nor
@@ -253,7 +254,7 @@
(ztest-normal ad-cmd :inline)
(ztest-opaque ad-cmd :inline)
(adcmd-offsets uint8 16) ;; which of the four A+D commands each effect combination needs
(adcmds ad-cmd 4 :overlay-at alpha-opaque)
(adcmds ad-cmd 4 :inline :overlay-at alpha-opaque)
(stcycle-tag uint32) ;; STCYCL CL=3 WL=1, which interleaves the three vertex streams
(unpack-vtx-tag uint32) ;; UNPACK V3-32, float positions
(unpack-clr-tag uint32) ;; UNPACK V4-8 unsigned, colors already in GS RGBAQ order
goal_src/jak1/engine/gfx/generic/generic-merc.gc
+25 -1
View File
@@ -3279,6 +3279,13 @@
insert each completed chain in its foreground bucket, and update wait and DMA-memory statistics."
(local-vars (a0-26 int) (a0-28 int))
(when (nonzero? (-> *merc-global-array* count))
(when *generic-effect-stats*
(set! (-> *generic-effect-debug-stats-data* light-vertices) 0)
(set! (-> *generic-effect-debug-stats-data* envmap-vertices) 0)
(set! (-> *generic-effect-debug-stats-data* prepare-single-calls) 0)
(set! (-> *generic-effect-debug-stats-data* prepare-double-calls) 0)
(stopwatch-init (-> *generic-effect-debug-stats-data* timer))
(stopwatch-start (-> *generic-effect-debug-stats-data* timer)))
(let ((global-buffer-start (-> *display* frames (-> *display* on-screen) frame global-buf base)))
;; set up performance stats
(if *debug-segment*
@@ -3302,6 +3309,13 @@
;; - high-speed-reject
;; and also loads the mercneric-vu0-block block with an offset of 280.
(generic-merc-init-asm)
;; Publish the GOAL implementations. MIPS2C calls these addresses through its ordinary
;; indirect-call bridge.
(let ((calls (-> (scratchpad-object terrain-context) work foreground generic-work in-buf merc shadow)))
(set! (-> calls generic-prepare-dma-single) generic-prepare-dma-single-new)
(set! (-> calls generic-prepare-dma-double) generic-prepare-dma-double-new)
(set! (-> calls generic-light-proc) generic-light-proc-new)
(set! (-> calls generic-envmap-proc) generic-envmap-proc-new))
;; set a limit, so we don't write off the end of the dma buffer.
(set! (-> (scratchpad-object terrain-context) work foreground generic-work in-buf merc shadow write-limit)
(&+ (-> dma-buf end) -65536))
@@ -3358,5 +3372,15 @@
(+! (-> dma-usage data 86 used)
(&- (-> *display* frames (-> *display* on-screen) frame global-buf base)
(the-as uint global-buffer-start)))
(set! (-> dma-usage data 86 total) (-> dma-usage data 86 used))))))
(set! (-> dma-usage data 86 total) (-> dma-usage data 86 used)))))
(when *generic-effect-stats*
(stopwatch-stop (-> *generic-effect-debug-stats-data* timer))
(format *stdcon*
"generic: ~D us, light ~D verts, envmap ~D verts, prepare single ~D, double ~D~%"
(the int (* 1000000.0
(stopwatch-elapsed-seconds (-> *generic-effect-debug-stats-data* timer))))
(-> *generic-effect-debug-stats-data* light-vertices)
(-> *generic-effect-debug-stats-data* envmap-vertices)
(-> *generic-effect-debug-stats-data* prepare-single-calls)
(-> *generic-effect-debug-stats-data* prepare-double-calls))))
(none))
goal_src/jak1/engine/gfx/generic/generic-tie.gc
+6 -4
View File
@@ -3347,10 +3347,12 @@
;; cached as addresses. TIE always wants this exact set: two packet headers, reflected
;; coordinates, the subdivision blend, and an unlit color combine.
(let ((calls (-> (scratchpad-object terrain-context) work foreground generic-work in-buf tie shadow calls)))
(set! (-> calls generic-prepare-dma-double) generic-prepare-dma-double)
(set! (-> calls generic-envmap-dproc) generic-envmap-dproc)
(set! (-> calls generic-interp-dproc) generic-interp-dproc)
(set! (-> calls generic-no-light-dproc) generic-no-light-dproc))
(set! (-> calls generic-prepare-dma-double) generic-prepare-dma-double-new)
;; The Generic TIE/dproc path is currently disabled and its PC implementations are absent.
;; (set! (-> calls generic-envmap-dproc) generic-envmap-dproc)
;; (set! (-> calls generic-interp-dproc) generic-interp-dproc)
;; (set! (-> calls generic-no-light-dproc) generic-no-light-dproc)
)
(set! (-> (scratchpad-object terrain-context) work foreground generic-work saves time-of-day-color r)
(the int (-> *time-of-day-context* current-sun env-color x)))
(set! (-> (scratchpad-object terrain-context) work foreground generic-work saves time-of-day-color g)