jaby
/
jabyengine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Revert back GTE usage and finalize code approach

This commit is contained in:
Jaby 2024-01-29 21:24:14 -05:00
parent 6771ef9db0
commit 1f43aeadb1
4 changed files with 115 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
include/PSX/GTE/gte.hpp
View File

@ -15,7 +15,12 @@ namespace JabyEngine {
output: Output vector output: Output vector
flag: flag output flag: flag output
*/ */
void rot_trans(const SVECTOR& input, VECTOR& output, int32_t& flag); void rot_trans(const SVECTOR& input, VECTOR& output, int32_t& flag) {
ldv0(input);
rt();
stlvnl(output);
stflg(flag);
}
/* /*
SetRotMatrix SetRotMatrix
@ -23,14 +28,32 @@ namespace JabyEngine {
Sets a 3x3 matrix m as a constant rotation matrix. Sets a 3x3 matrix m as a constant rotation matrix.
matrix: The rotation matrix to set matrix: The rotation matrix to set
*/ */
void set_rot_matrix(const MATRIX& matrix); void set_rot_matrix(const MATRIX& matrix) {
__asm__ volatile("lw $12, 0(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $13, 4(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $12, $0" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $13, $1" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $12, 8(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $13, 12(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $14, 16(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $12, $2" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $13, $3" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $14, $4" :: "r"(&matrix) : "$12", "$13", "$14");
}
/* /*
SetTransMatrix SetTransMatrix
Sets a constant parallel transfer vector specified by m Sets a constant parallel transfer vector specified by m
*/ */
void set_trans_matrix(const MATRIX& matrix); void set_trans_matrix(const MATRIX& matrix) {
__asm__ volatile("lw $12, 20(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $13, 24(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $12, $5" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $14, 28(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $13, $6" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $14, $7" :: "r"(&matrix) : "$12", "$13", "$14");
}
/* /*
MulMatrix0 MulMatrix0
@ -43,20 +66,27 @@ namespace JabyEngine {
Multiplies two matrices m0 and m1. Multiplies two matrices m0 and m1.
The function destroys the constant rotation matrix The function destroys the constant rotation matrix
*/ */
MATRIX& mult_matrix(const MATRIX& m0, const MATRIX& m1, MATRIX& result); MATRIX& multiply_matrix(const MATRIX& m0, const MATRIX& m1, MATRIX& result);
/* /*
SetGeomOffset(ofx,ofy) SetGeomOffset(ofx,ofy)
Load GTE-offset. Load GTE-offset.
*/ */
void set_geom_offset(int32_t off_x, int32_t off_y); void set_geom_offset(int32_t off_x, int32_t off_y) {
__asm__ volatile("sll $12, %0, 16" :: "r"(off_x), "r"(off_y) : "$12", "$13");
__asm__ volatile("sll $13, %1, 16" :: "r"(off_x), "r"(off_y) : "$12", "$13");
__asm__ volatile("ctc2 $12, $24" :: "r"(off_x), "r"(off_y) : "$12", "$13");
__asm__ volatile("ctc2 $13, $25" :: "r"(off_x), "r"(off_y) : "$12", "$13");
}
/* /*
SetGeomScreen(h) SetGeomScreen(h)
Load distance from viewpoint to screen. Load distance from viewpoint to screen.
*/ */
void set_geom_screen(int32_t h); void set_geom_screen(int32_t h) {
__asm__ volatile("ctc2 %0, $26" :: "r"(h));
}
} }
} }

148
include/PSX/GTE/gte_instruction.hpp
View File

@ -1,94 +1,78 @@
#pragma once #pragma once
#include "gte_types.hpp" #include "gte_types.hpp"
#ifdef __INTELLISENSE__ namespace JabyEngine {
// Load vertex or normal to vertex register 0 namespace GTE {
void __jaby_engine_gte_ldv0(const JabyEngine::GTE::SVECTOR& vector); // Load vertex or normal to vertex register 0
static __always_inline void ldv0(const SVECTOR& vector) {
__asm__ volatile("lwc2 $0, 0(%0)" :: "r"(&vector));
__asm__ volatile("lwc2 $1, 4(%0)" :: "r"(&vector));
}
// Load vertex or normal to vertex register 1 // Load vertex or normal to vertex register 1
void __jaby_engine_gte_ldv1(const JabyEngine::GTE::SVECTOR& vector); static __always_inline void ldv1(const SVECTOR& vector) {
__asm__ volatile("lwc2 $2, 0(%0)" :: "r"(&vector));
__asm__ volatile("lwc2 $3, 4(%0)" :: "r"(&vector));
}
// Load vertex or normal to vertex register 2 // Load vertex or normal to vertex register 2
void __jaby_engine_gte_ldv2(const JabyEngine::GTE::SVECTOR& vector); static __always_inline void ldv2(const SVECTOR& vector) {
__asm__ volatile("lwc2 $4, 0(%0)" :: "r"(&vector));
__asm__ volatile("lwc2 $5, 4(%0)" :: "r"(&vector));
}
// Load column vector of JabyEngine::GTE::MATRIX to universal register // Load column vector of MATRIX to universal register
void __jaby_engine_gte_ldclmv(const JabyEngine::GTE::MATRIX& matrix, size_t col); static __always_inline void ldclmv(const MATRIX& matrix, size_t col) {
__asm__ volatile("lhu $12, 0(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14");
__asm__ volatile("lhu $13, 6(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14");
__asm__ volatile("lhu $14, 12(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14");
__asm__ volatile("mtc2 $12, $9" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14");
__asm__ volatile("mtc2 $13, $10" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14");
__asm__ volatile("mtc2 $14, $11" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14");
}
// Store flag // Store flag
void __jaby_engine_gte_stflg(int32_t& flag); static __always_inline void stflg(int32_t& flag) {
__asm__ volatile("cfc2 $12, $31" :: "r"(&flag) : "$12", "memory");
__asm__ volatile("nop" :: "r"(&flag) : "$12", "memory");
__asm__ volatile("sw $12, 0(%0)" :: "r"(&flag) : "$12", "memory");
}
// Store JabyEngine::GTE::MATRIX column from 16 bit universal register // Store MATRIX column from 16 bit universal register
void __jaby_engine_gte_stclmv(JabyEngine::GTE::MATRIX& matrix, size_t col); static __always_inline void stclmv(MATRIX& matrix, size_t col) {
__asm__ volatile("mfc2 $12, $9" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory");
__asm__ volatile("mfc2 $13, $10" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory");
__asm__ volatile("mfc2 $14, $11" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory");
__asm__ volatile("sh $12, 0(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory");
__asm__ volatile("sh $13, 6(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory");
__asm__ volatile("sh $14, 12(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory");
}
// Store VECTOR from 32 bit universal register // Store VECTOR from 32 bit universal register
void __jaby_engine_gte_stlvnl(JabyEngine::GTE::VECTOR& out_vector); static __always_inline void stlvnl(VECTOR& out_vector) {
__asm__ volatile("swc2 $25, 0(%0)" :: "r"(&out_vector) : "memory");
__asm__ volatile("swc2 $26, 4(%0)" :: "r"(&out_vector) : "memory");
__asm__ volatile("swc2 $27, 8(%0)" :: "r"(&out_vector) : "memory");
}
/* /*
Kernel of RotTrans Kernel of RotTrans
(Transfer vector)+(Rotation Matrix)*(vertex register 0) (Transfer vector)+(Rotation Matrix)*(vertex register 0)
*/ */
void __jaby_engine_gte_rt(); static __always_inline void rt() {
__asm__ volatile("nop");
__asm__ volatile("nop");
__asm__ volatile("cop2 0x0480012");
}
/* /*
Variation of gte_rt Variation of gte_rt
(Rotation Matrix)*(16 bit universal vector) (Rotation Matrix)*(16 bit universal vector)
*/ */
void __jaby_engine_gte_rtir(); static __always_inline void rtir() {
#else __asm__ volatile("nop");
#define __jaby_engine_gte_ldv0(vector) { \ __asm__ volatile("nop");
__asm__ volatile("lwc2 $0, 0(%0)" :: "r"(&vector)); \ __asm__ volatile("cop2 0x049E012");
__asm__ volatile("lwc2 $1, 4(%0)" :: "r"(&vector)); \ }
} }
}
#define __jaby_engine_gte_ldv1(vector) { \
__asm__ volatile("lwc2 $2, 0(%0)" :: "r"(&vector)); \
__asm__ volatile("lwc2 $3, 4(%0)" :: "r"(&vector)); \
}
#define __jaby_engine_gte_ldv2(vector) { \
__asm__ volatile("lwc2 $4, 0(%0)" :: "r"(&vector)); \
__asm__ volatile("lwc2 $5, 4(%0)" :: "r"(&vector)); \
}
#define __jaby_engine_gte_ldclmv(matrix, col) { \
__asm__ volatile("lhu $12, 0(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14"); \
__asm__ volatile("lhu $13, 6(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14"); \
__asm__ volatile("lhu $14, 12(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14"); \
__asm__ volatile("mtc2 $12, $9" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14"); \
__asm__ volatile("mtc2 $13, $10" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14"); \
__asm__ volatile("mtc2 $14, $11" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14"); \
}
#define __jaby_engine_gte_stflg(flag) { \
__asm__ volatile("cfc2 $12, $31" :: "r"(&flag) : "$12", "memory"); \
__asm__ volatile("nop" :: "r"(&flag) : "$12", "memory"); \
__asm__ volatile("sw $12, 0(%0)" :: "r"(&flag) : "$12", "memory"); \
}
#define __jaby_engine_gte_stclmv(matrix, col) { \
__asm__ volatile("mfc2 $12, $9" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory"); \
__asm__ volatile("mfc2 $13, $10" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory"); \
__asm__ volatile("mfc2 $14, $11" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory"); \
__asm__ volatile("sh $12, 0(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory"); \
__asm__ volatile("sh $13, 6(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory"); \
__asm__ volatile("sh $14, 12(%0)" :: "r"(reinterpret_cast<uintptr_t>(&matrix) + (col << 1)) : "$12", "$13", "$14", "memory"); \
}
#define __jaby_engine_gte_stlvnl(out_vector) { \
__asm__ volatile("swc2 $25, 0(%0)" :: "r"(&out_vector) : "memory"); \
__asm__ volatile("swc2 $26, 4(%0)" :: "r"(&out_vector) : "memory"); \
__asm__ volatile("swc2 $27, 8(%0)" :: "r"(&out_vector) : "memory"); \
}
#define __jaby_engine_gte_rt() { \
__asm__ volatile("nop"); \
__asm__ volatile("nop"); \
__asm__ volatile("cop2 0x0480012"); \
}
#define __jaby_engine_gte_rtir() { \
__asm__ volatile("nop"); \
__asm__ volatile("nop"); \
__asm__ volatile("cop2 0x049E012"); \
}
#endif

8
src/Library/src/BootLoader/start_boot.cpp
View File

@ -85,11 +85,9 @@ namespace JabyEngine {
const auto m1 = GTE::MATRIX::identity(); const auto m1 = GTE::MATRIX::identity();
auto m2 = GTE::MATRIX::identity(); auto m2 = GTE::MATRIX::identity();
asm("# PLANSCHI START");
GTE::mult_matrix(m0, m1, m2); JabyEngine::GTE::multiply_matrix(m0, m1, m2);
asm("# THEIR PLANSCHI START"); asm("# PLANSCHI END");
gte_MulMatrix0(&m0, &m1, &m2);
asm("# THEIR PLANSCHI END");
} }
void start() { void start() {

66
src/Library/src/GTE/gte.cpp
View File

@ -2,68 +2,22 @@
namespace JabyEngine { namespace JabyEngine {
namespace GTE { namespace GTE {
void rot_trans(const SVECTOR& input, VECTOR& output, int32_t& flag) { MATRIX& multiply_matrix(const MATRIX& m0, const MATRIX& m1, MATRIX& result) {
__jaby_engine_gte_ldv0(input);
__jaby_engine_gte_rt();
__jaby_engine_gte_stlvnl(output);
__jaby_engine_gte_stflg(flag);
}
void set_rot_matrix(const MATRIX& matrix) {
__asm__ volatile("lw $12, 0(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $13, 4(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $12, $0" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $13, $1" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $12, 8(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $13, 12(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $14, 16(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $12, $2" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $13, $3" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $14, $4" :: "r"(&matrix) : "$12", "$13", "$14");
}
void set_trans_matrix(const MATRIX& matrix) {
__asm__ volatile("lw $12, 20(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $13, 24(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $12, $5" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("lw $14, 28(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $13, $6" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $14, $7" :: "r"(&matrix) : "$12", "$13", "$14");
}
MATRIX& mult_matrix(const MATRIX& m0, const MATRIX& m1, MATRIX& result) {
/*
Jaby: Somehow this code creates stack usage.... Investigate!!
Jaby: Reimplement all of this with the original code and see how it goes?!
*/
asm("# MY PLANSCHI START");
set_rot_matrix(m0); set_rot_matrix(m0);
__jaby_engine_gte_ldclmv(m1, 0); JabyEngine::GTE::ldclmv(m1, 0);
__jaby_engine_gte_rtir(); JabyEngine::GTE::rtir();
__jaby_engine_gte_stclmv(result, 0); JabyEngine::GTE::stclmv(result, 0);
__jaby_engine_gte_ldclmv(m1, 1); JabyEngine::GTE::ldclmv(m1, 1);
__jaby_engine_gte_rtir(); JabyEngine::GTE::rtir();
__jaby_engine_gte_stclmv(result, 1); JabyEngine::GTE::stclmv(result, 1);
__jaby_engine_gte_ldclmv(m1, 2); JabyEngine::GTE::ldclmv(m1, 2);
__jaby_engine_gte_rtir(); JabyEngine::GTE::rtir();
__jaby_engine_gte_stclmv(result, 2); JabyEngine::GTE::stclmv(result, 2);
return result; return result;
asm("# MY PLANSCHI END");
}
void set_geom_offset(int32_t off_x, int32_t off_y) {
__asm__ volatile("sll $12, %0, 16" :: "r"(off_x), "r"(off_y) : "$12", "$13");
__asm__ volatile("sll $13, %1, 16" :: "r"(off_x), "r"(off_y) : "$12", "$13");
__asm__ volatile("ctc2 $12, $24" :: "r"(off_x), "r"(off_y) : "$12", "$13");
__asm__ volatile("ctc2 $13, $25" :: "r"(off_x), "r"(off_y) : "$12", "$13");
}
void set_geom_screen(int32_t h) {
__asm__ volatile("ctc2 %0, $26" :: "r"(h));
} }
} }
} }