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

Add seperation between ROTMATRIX and TRANSFERVECTOR

This commit is contained in:
jaby 2024-04-02 23:40:22 -05:00
parent 4da6772827
commit 1bf91b2d75
7 changed files with 73 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
examples/PoolBox/application/src/Overlay/GTETest/gte_test.cpp
View File

@ -30,10 +30,10 @@ namespace GTETest {
return true;
}
auto matrix = GTE::MATRIX::rotation(0, 0, rotation);
matrix.trans[0] = (Assets::Main::DoenerFishInfo.size.width/2);
matrix.trans[1] = (Assets::Main::DoenerFishInfo.size.height/2);
const auto matrix = GTE::MATRIX{
GTE::ROTMATRIX::rotated(-rotation, rotation, -rotation),
GTE::TRANSFERVECTOR::translated((Assets::Main::DoenerFishInfo.size.width/2), (Assets::Main::DoenerFishInfo.size.height/2))
};
doener_fish.apply(matrix);
rotation += 5_DEG;
return false;

8
examples/PoolBox/application/src/Overlay/GTETest/include/GTE_Sprite.hpp
View File

@ -19,14 +19,12 @@ namespace GTETest {
void apply(const GTE::MATRIX& matrix) {
static const auto apply_to = [](const GTE::MATRIX& matrix, GTE::SVECTOR vector) -> GPU::Vertex {
GTE::MATRIX move_back = GTE::MATRIX::identity();
GTE::MATRIX move_back = GTE::MATRIX{
GTE::ROTMATRIX::identity(), GTE::TRANSFERVECTOR::translated(-matrix.transfer.x, -matrix.transfer.y, -matrix.transfer.z)
};
GTE::SVECTOR output;
int32_t flag;
move_back.trans[0] = -matrix.trans[0];
move_back.trans[1] = -matrix.trans[1];
move_back.trans[2] = -matrix.trans[2];
GTE::comp_matrix(matrix, move_back, move_back);
return GTE::apply_matrix(move_back, vector, output).to<GPU::Vertex>();
};

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

@ -30,7 +30,7 @@ namespace JabyEngine {
Sets a 3x3 matrix m as a constant rotation matrix.
matrix: The rotation matrix to set
*/
static void set_rot_matrix(const MATRIX& matrix) {
static void set_rot_matrix(const ROTMATRIX& 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");
@ -49,7 +49,7 @@ namespace JabyEngine {
Writes the current 3x3 constant rotation matrix to matrix
(This doesn't require us to use memory clobber)
*/
static void get_rot_matrix(MATRIX &matrix) {
static void get_rot_matrix(ROTMATRIX &matrix) {
__asm__ volatile("cfc2 $12, $0" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("cfc2 $13, $1" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("sw $12, 0(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
@ -67,13 +67,13 @@ namespace JabyEngine {
Sets a constant parallel transfer vector specified by m
*/
static 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");
static void set_trans_vector(const TRANSFERVECTOR& vector) {
__asm__ volatile("lw $12, 0(%0)" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("lw $13, 4(%0)" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $12, $5" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("lw $14, 8(%0)" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $13, $6" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("ctc2 $14, $7" :: "r"(&vector) : "$12", "$13", "$14");
}
/*
@ -82,13 +82,13 @@ namespace JabyEngine {
Writes the current constant parallel transfer vector to matrix
(This doesn't require us to use memory clobber)
*/
static void get_trans_matrix(MATRIX& matrix) {
__asm__ volatile("cfc2 $14, $7" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("cfc2 $13, $6" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("sw $14, 28(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("cfc2 $12, $5" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("sw $13, 24(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
__asm__ volatile("sw $12, 20(%0)" :: "r"(&matrix) : "$12", "$13", "$14");
static void get_trans_vector(TRANSFERVECTOR& vector) {
__asm__ volatile("cfc2 $14, $7" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("cfc2 $13, $6" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("sw $14, 8(%0)" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("cfc2 $12, $5" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("sw $13, 4(%0)" :: "r"(&vector) : "$12", "$13", "$14");
__asm__ volatile("sw $12, 0(%0)" :: "r"(&vector) : "$12", "$13", "$14");
}
/*
@ -113,7 +113,7 @@ namespace JabyEngine {
Multiplies two matrices m0 and m1.
The function destroys the constant rotation matrix
*/
MATRIX& multiply_matrix(const MATRIX& m0, const MATRIX& m1, MATRIX& result);
ROTMATRIX& multiply_matrix(const ROTMATRIX& m0, const ROTMATRIX& m1, ROTMATRIX& result);
/*
CompMatrix
@ -124,11 +124,11 @@ namespace JabyEngine {
return: returns result
*/
static MATRIX& comp_matrix(const MATRIX& m0, const MATRIX& m1, MATRIX& result) {
multiply_matrix(m0, m1, result);
set_trans_matrix(m0);
GTE::ldlv0(reinterpret_cast<const VECTOR&>(m1.trans));
multiply_matrix(m0.rotation, m1.rotation, result.rotation);
set_trans_vector(m0.transfer);
GTE::ldlv0(reinterpret_cast<const VECTOR&>(m1.transfer));
GTE::rt();
GTE::stlvnl(reinterpret_cast<VECTOR&>(result.trans));
GTE::stlvnl(reinterpret_cast<VECTOR&>(result.transfer));
return result;
}

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

@ -33,7 +33,7 @@ namespace JabyEngine {
}
// Load column vector of MATRIX to universal register
static __always_inline void ldclmv(const MATRIX& matrix, size_t col) {
static __always_inline void ldclmv(const ROTMATRIX& 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");
@ -50,7 +50,7 @@ namespace JabyEngine {
}
// Store MATRIX column from 16 bit universal register
static __always_inline void stclmv(MATRIX& matrix, size_t col) {
static __always_inline void stclmv(ROTMATRIX& 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");

44
include/PSX/GTE/gte_types.hpp
View File

@ -10,14 +10,13 @@ namespace JabyEngine {
T x;
T y;
T z;
T pad;
static constexpr VECTOR create() {
return VECTOR::create(0, 0, 0);
}
static constexpr VECTOR create(T x, T y, T z) {
return VECTOR{.x = x, .y = y, .z = z, .pad = 0};
return VECTOR{.x = x, .y = y, .z = z};
}
template<typename S>
@ -31,28 +30,41 @@ namespace JabyEngine {
}
};
}
using VECTOR = internal::VECTOR<int32_t>;
using SVECTOR = internal::VECTOR<int16_t>;
// TODO: Split MATRIX into ROTMATRIX and TRANSFERVECTOR or something like that. But first get it running
struct MATRIX {
int16_t rot[3][3]; // Rotation matrix
int32_t trans[3]; // Translation vector
struct ROTMATRIX {
int16_t matrix[3][3];
static constexpr MATRIX identity() {
return MATRIX{
.rot = {
static constexpr ROTMATRIX identity() {
return ROTMATRIX{.matrix = {
{4096, 0, 0},
{0, 4096, 0},
{0, 0, 4096}
},
.trans = {0, 0, 0}
}
};
}
static MATRIX rotation(int32_t x, int32_t y, int32_t z);
} // TODO: replace int32_t with something weird for the DEG stuff??
static ROTMATRIX rotated(int32_t x, int32_t y, int32_t z);
};
using VECTOR = internal::VECTOR<int32_t>;
using SVECTOR = internal::VECTOR<int16_t>;
struct TRANSFERVECTOR : public VECTOR {
static constexpr TRANSFERVECTOR identity() {
return TRANSFERVECTOR::translated();
}
static constexpr TRANSFERVECTOR translated(int32_t x = 0, int32_t y = 0, int32_t z = 0) {
return TRANSFERVECTOR{{.x = x, .y = y, .z = z}};
}
};
struct MATRIX {
ROTMATRIX rotation;
TRANSFERVECTOR transfer;
static constexpr MATRIX identity() {
return MATRIX{.rotation = ROTMATRIX::identity(), .transfer = TRANSFERVECTOR::identity()};
}
};
static constexpr auto one_degree = FULL_CIRCLE/360;
static constexpr auto one_tenth_degree = FULL_CIRCLE/3600;

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

@ -32,74 +32,6 @@ namespace JabyEngine {
}
}
static void test_gte() {
#define gte_MulMatrix0(r1,r2,r3) \
{ gte_SetRotMatrix(r1); \
gte_ldclmv(r2); \
gte_rtir(); \
gte_stclmv(r3); \
gte_ldclmv((char*)r2+2);\
gte_rtir(); \
gte_stclmv((char*)r3+2);\
gte_ldclmv((char*)r2+4);\
gte_rtir(); \
gte_stclmv((char*)r3+4); }
const auto m0 = GTE::MATRIX::identity();
const auto m1 = GTE::MATRIX::identity();
auto m2 = GTE::MATRIX::identity();
asm("# PLANSCHI START");
JabyEngine::GTE::multiply_matrix(m0, m1, m2);
asm("# PLANSCHI END");
#define PI 3.14159265 // v 90°???
static const auto display_stuff = [](int32_t angle) {
static const auto wanna_be_float = [](int32_t value) -> int32_t {
return (value*10000)/(4096);
};
const auto sin_value = sin(GTE::in_degree(angle));
const auto cos_value = cos(GTE::in_degree(angle));
printf("Sine of %i = %i (%i)\n", angle, sin_value, wanna_be_float(sin_value));
printf("Cos of %i = %i (%i)\n", angle, cos_value, wanna_be_float(cos_value));
};
static const auto print_matrix = [](const GTE::MATRIX& matrix) {
printf("{%i, %i, %i}\n", matrix.rot[0][0], matrix.rot[0][1], matrix.rot[0][2]);
printf("{%i, %i, %i}\n", matrix.rot[1][0], matrix.rot[1][1], matrix.rot[1][2]);
printf("{%i, %i, %i}\n", matrix.rot[2][0], matrix.rot[2][1], matrix.rot[2][2]);
printf("{%i, %i, %i}\n", matrix.trans[0], matrix.trans[1], matrix.trans[2]);
};
static const auto make_matrix = [](int16_t mult) -> GTE::MATRIX {
return GTE::MATRIX {
.rot = {
{static_cast<int16_t>(1*mult), static_cast<int16_t>(2*mult), static_cast<int16_t>(3*mult)},
{static_cast<int16_t>(2*mult), static_cast<int16_t>(3*mult), static_cast<int16_t>(1*mult)},
{static_cast<int16_t>(3*mult), static_cast<int16_t>(1*mult), static_cast<int16_t>(2*mult)},
},
.trans = {6*mult, 7*mult, 8*mult}
};
};
display_stuff(25);
display_stuff(45);
display_stuff(75);
display_stuff(90);
for(size_t n = 0; n < 3; n++) {
GTE::push_matrix_and_set(make_matrix(n + 1));
}
for(size_t n = 0; n < 3; n++) {
print_matrix(GTE::get_and_pop_matrix());
printf("---\n");
}
}
namespace boot {
namespace Start {
static void setup() {
@ -128,7 +60,6 @@ namespace JabyEngine {
GPU::display_logo();
GTE::setup();
test_bios_font();
test_gte();
//Pause??
SPU::setup();

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

@ -53,7 +53,7 @@ namespace JabyEngine {
return v1;
}
MATRIX& multiply_matrix(const MATRIX& m0, const MATRIX& m1, MATRIX& result) {
ROTMATRIX& multiply_matrix(const ROTMATRIX& m0, const ROTMATRIX& m1, ROTMATRIX& result) {
set_rot_matrix(m0);
JabyEngine::GTE::ldclmv(m1, 0);
@ -72,15 +72,15 @@ namespace JabyEngine {
}
void set_matrix(const MATRIX& matrix) {
set_rot_matrix(matrix);
set_trans_matrix(matrix);
set_rot_matrix(matrix.rotation);
set_trans_vector(matrix.transfer);
}
MATRIX get_matrix() {
MATRIX matrix;
get_rot_matrix(matrix);
get_trans_matrix(matrix);
get_rot_matrix(matrix.rotation);
get_trans_vector(matrix.transfer);
return matrix;
}
@ -106,24 +106,24 @@ namespace JabyEngine {
return matrix;
}
MATRIX MATRIX :: rotation(int32_t x, int32_t y, int32_t z) {
ROTMATRIX ROTMATRIX :: rotated(int32_t x, int32_t y, int32_t z) {
using namespace MatrixHelper;
const auto sincos_x = SinCosPair::create_for(x);
const auto sincos_y = SinCosPair::create_for(y);
const auto sincos_z = SinCosPair::create_for(z);
auto rotX = MATRIX::identity();
rotX.rot[1][1] = sincos_x.cos; rotX.rot[1][2] = -sincos_x.sin;
rotX.rot[2][1] = sincos_x.sin; rotX.rot[2][2] = sincos_x.cos;
auto rotX = ROTMATRIX::identity();
rotX.matrix[1][1] = sincos_x.cos; rotX.matrix[1][2] = -sincos_x.sin;
rotX.matrix[2][1] = sincos_x.sin; rotX.matrix[2][2] = sincos_x.cos;
auto rotY = MATRIX::identity();
rotY.rot[0][0] = sincos_y.cos; rotY.rot[0][2] = sincos_y.sin;
rotY.rot[2][0] = -sincos_y.sin; rotY.rot[2][2] = sincos_y.cos;
auto rotY = ROTMATRIX::identity();
rotY.matrix[0][0] = sincos_y.cos; rotY.matrix[0][2] = sincos_y.sin;
rotY.matrix[2][0] = -sincos_y.sin; rotY.matrix[2][2] = sincos_y.cos;
auto rotZ = MATRIX::identity();
rotZ.rot[0][0] = sincos_z.cos; rotZ.rot[0][1] = -sincos_z.sin;
rotZ.rot[1][0] = sincos_z.sin; rotZ.rot[1][1] = sincos_z.cos;
auto rotZ = ROTMATRIX::identity();
rotZ.matrix[0][0] = sincos_z.cos; rotZ.matrix[0][1] = -sincos_z.sin;
rotZ.matrix[1][0] = sincos_z.sin; rotZ.matrix[1][1] = sincos_z.cos;
push_matrix();
multiply_matrix(rotX, rotY, rotX);