Zxc200611/pocketpy
1
0
Fork 0
mirror of https://github.com/pocketpy/pocketpy synced 2025-10-20 11:30:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove PyVec*

Browse Source
This commit is contained in:
blueloveTH 2024-03-01 18:18:41 +08:00
parent 21c2801f28
commit d5c93c666e
2 changed files with 142 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
include/pocketpy/linalg.h
View File

@ -7,6 +7,11 @@ namespace pkpy{
inline bool isclose(float a, float b){ return std::fabs(a - b) <= NumberTraits<4>::kEpsilon; } inline bool isclose(float a, float b){ return std::fabs(a - b) <= NumberTraits<4>::kEpsilon; }
struct Vec2{ struct Vec2{
PY_CLASS(Vec2, linalg, vec2)
Vec2* _() { return this; }
static void _register(VM* vm, PyObject* mod, PyObject* type);
float x, y; float x, y;
Vec2() : x(0.0f), y(0.0f) {} Vec2() : x(0.0f), y(0.0f) {}
Vec2(float x, float y) : x(x), y(y) {} Vec2(float x, float y) : x(x), y(y) {}
@ -30,6 +35,11 @@ struct Vec2{
}; };
struct Vec3{ struct Vec3{
PY_CLASS(Vec3, linalg, vec3)
Vec3* _() { return this; }
static void _register(VM* vm, PyObject* mod, PyObject* type);
float x, y, z; float x, y, z;
Vec3() : x(0.0f), y(0.0f), z(0.0f) {} Vec3() : x(0.0f), y(0.0f), z(0.0f) {}
Vec3(float x, float y, float z) : x(x), y(y), z(z) {} Vec3(float x, float y, float z) : x(x), y(y), z(z) {}
@ -52,6 +62,11 @@ struct Vec3{
}; };
struct Vec4{ struct Vec4{
PY_CLASS(Vec4, linalg, vec4)
Vec4* _() { return this; }
static void _register(VM* vm, PyObject* mod, PyObject* type);
float x, y, z, w; float x, y, z, w;
Vec4() : x(0.0f), y(0.0f), z(0.0f), w(0.0f) {} Vec4() : x(0.0f), y(0.0f), z(0.0f), w(0.0f) {}
Vec4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {} Vec4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {}
@ -72,7 +87,12 @@ struct Vec4{
NoReturn copy_(const Vec4& v) { x = v.x; y = v.y; z = v.z; w = v.w; return {}; } NoReturn copy_(const Vec4& v) { x = v.x; y = v.y; z = v.z; w = v.w; return {}; }
}; };
struct Mat3x3{ struct Mat3x3{
PY_CLASS(Mat3x3, linalg, mat3x3)
Mat3x3* _(){ return this; }
static void _register(VM* vm, PyObject* mod, PyObject* type);
union { union {
struct { struct {
float _11, _12, _13; float _11, _12, _13;
@ -113,74 +133,18 @@ struct Mat3x3{
Vec2 _s() const; Vec2 _s() const;
}; };
struct PyVec2: Vec2 {
PY_CLASS(PyVec2, linalg, vec2)
PyVec2() : Vec2() {} inline PyObject* py_var(VM* vm, Vec2 obj){ return VAR_T(Vec2, obj); }
PyVec2(const Vec2& v) : Vec2(v) {} inline PyObject* py_var(VM* vm, Vec3 obj){ return VAR_T(Vec3, obj); }
Vec2* _() { return this; } inline PyObject* py_var(VM* vm, Vec4 obj){ return VAR_T(Vec4, obj); }
inline PyObject* py_var(VM* vm, const Mat3x3& obj){ return VAR_T(Mat3x3, obj); }
static void _register(VM* vm, PyObject* mod, PyObject* type);
};
struct PyVec3: Vec3 {
PY_CLASS(PyVec3, linalg, vec3)
PyVec3() : Vec3() {}
PyVec3(const Vec3& v) : Vec3(v) {}
Vec3* _() { return this; }
static void _register(VM* vm, PyObject* mod, PyObject* type);
};
struct PyVec4: Vec4{
PY_CLASS(PyVec4, linalg, vec4)
PyVec4(): Vec4(){}
PyVec4(const Vec4& v): Vec4(v){}
Vec4* _(){ return this; }
static void _register(VM* vm, PyObject* mod, PyObject* type);
};
struct PyMat3x3: Mat3x3{
PY_CLASS(PyMat3x3, linalg, mat3x3)
PyMat3x3(): Mat3x3(){}
PyMat3x3(const Mat3x3& other): Mat3x3(other){}
Mat3x3* _(){ return this; }
static void _register(VM* vm, PyObject* mod, PyObject* type);
};
inline PyObject* py_var(VM* vm, Vec2 obj){ return VAR_T(PyVec2, obj); }
inline PyObject* py_var(VM* vm, const PyVec2& obj){ return VAR_T(PyVec2, obj);}
inline PyObject* py_var(VM* vm, Vec3 obj){ return VAR_T(PyVec3, obj); }
inline PyObject* py_var(VM* vm, const PyVec3& obj){ return VAR_T(PyVec3, obj);}
inline PyObject* py_var(VM* vm, Vec4 obj){ return VAR_T(PyVec4, obj); }
inline PyObject* py_var(VM* vm, const PyVec4& obj){ return VAR_T(PyVec4, obj);}
inline PyObject* py_var(VM* vm, const Mat3x3& obj){ return VAR_T(PyMat3x3, obj); }
inline PyObject* py_var(VM* vm, const PyMat3x3& obj){ return VAR_T(PyMat3x3, obj); }
template<> inline Vec2 py_cast<Vec2>(VM* vm, PyObject* obj) { return CAST(PyVec2&, obj); }
template<> inline Vec3 py_cast<Vec3>(VM* vm, PyObject* obj) { return CAST(PyVec3&, obj); }
template<> inline Vec4 py_cast<Vec4>(VM* vm, PyObject* obj) { return CAST(PyVec4&, obj); }
template<> inline Mat3x3 py_cast<Mat3x3>(VM* vm, PyObject* obj) { return CAST(PyMat3x3&, obj); }
template<> inline Vec2 _py_cast<Vec2>(VM* vm, PyObject* obj) { return _CAST(PyVec2&, obj); }
template<> inline Vec3 _py_cast<Vec3>(VM* vm, PyObject* obj) { return _CAST(PyVec3&, obj); }
template<> inline Vec4 _py_cast<Vec4>(VM* vm, PyObject* obj) { return _CAST(PyVec4&, obj); }
template<> inline Mat3x3 _py_cast<Mat3x3>(VM* vm, PyObject* obj) { return _CAST(PyMat3x3&, obj); }
void add_module_linalg(VM* vm); void add_module_linalg(VM* vm);
static_assert(sizeof(Py_<PyMat3x3>) <= 64); static_assert(sizeof(Py_<Mat3x3>) <= 64);
static_assert(std::is_trivially_copyable<PyVec2>::value); static_assert(std::is_trivially_copyable<Vec2>::value);
static_assert(std::is_trivially_copyable<PyVec3>::value); static_assert(std::is_trivially_copyable<Vec3>::value);
static_assert(std::is_trivially_copyable<PyVec4>::value); static_assert(std::is_trivially_copyable<Vec4>::value);
static_assert(std::is_trivially_copyable<PyMat3x3>::value); static_assert(std::is_trivially_copyable<Mat3x3>::value);
} // namespace pkpy } // namespace pkpy

224
src/linalg.cpp
View File

@ -4,54 +4,54 @@ namespace pkpy{
#define BIND_VEC_VEC_OP(D, name, op) \ #define BIND_VEC_VEC_OP(D, name, op) \
vm->bind##name(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \ vm->bind##name(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \
PyVec##D& self = _CAST(PyVec##D&, _0); \ Vec##D& self = _CAST(Vec##D&, _0); \
PyVec##D& other = CAST(PyVec##D&, _1); \ Vec##D& other = CAST(Vec##D&, _1); \
return VAR(self op other); \ return VAR(self op other); \
}); });
#define BIND_VEC_FLOAT_OP(D, name, op) \ #define BIND_VEC_FLOAT_OP(D, name, op) \
vm->bind##name(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \ vm->bind##name(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \
PyVec##D& self = _CAST(PyVec##D&, _0); \ Vec##D& self = _CAST(Vec##D&, _0); \
f64 other = CAST(f64, _1); \ f64 other = CAST(f64, _1); \
return VAR(self op other); \ return VAR(self op other); \
}); });
#define BIND_VEC_FUNCTION_0(D, name) \ #define BIND_VEC_FUNCTION_0(D, name) \
vm->bind_method<0>(type, #name, [](VM* vm, ArgsView args){ \ vm->bind_method<0>(type, #name, [](VM* vm, ArgsView args){ \
PyVec##D& self = _CAST(PyVec##D&, args[0]); \ Vec##D& self = _CAST(Vec##D&, args[0]); \
return VAR(self.name()); \ return VAR(self.name()); \
}); });
#define BIND_VEC_FUNCTION_1(D, name) \ #define BIND_VEC_FUNCTION_1(D, name) \
vm->bind_method<1>(type, #name, [](VM* vm, ArgsView args){ \ vm->bind_method<1>(type, #name, [](VM* vm, ArgsView args){ \
PyVec##D& self = _CAST(PyVec##D&, args[0]); \ Vec##D& self = _CAST(Vec##D&, args[0]); \
PyVec##D& other = CAST(PyVec##D&, args[1]); \ Vec##D& other = CAST(Vec##D&, args[1]); \
return VAR(self.name(other)); \ return VAR(self.name(other)); \
}); });
#define BIND_VEC_MUL_OP(D) \ #define BIND_VEC_MUL_OP(D) \
vm->bind__mul__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \ vm->bind__mul__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \
PyVec##D& self = _CAST(PyVec##D&, _0); \ Vec##D& self = _CAST(Vec##D&, _0); \
if(is_non_tagged_type(_1, PyVec##D::_type(vm))){ \ if(is_non_tagged_type(_1, Vec##D::_type(vm))){ \
PyVec##D& other = _CAST(PyVec##D&, _1); \ Vec##D& other = _CAST(Vec##D&, _1); \
return VAR(self * other); \ return VAR(self * other); \
} \ } \
f64 other = CAST(f64, _1); \ f64 other = CAST(f64, _1); \
return VAR(self * other); \ return VAR(self * other); \
}); \ }); \
vm->bind_method<1>(type, "__rmul__", [](VM* vm, ArgsView args){ \ vm->bind_method<1>(type, "__rmul__", [](VM* vm, ArgsView args){ \
PyVec##D& self = _CAST(PyVec##D&, args[0]); \ Vec##D& self = _CAST(Vec##D&, args[0]); \
f64 other = CAST(f64, args[1]); \ f64 other = CAST(f64, args[1]); \
return VAR(self * other); \ return VAR(self * other); \
}); \ }); \
vm->bind__truediv__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \ vm->bind__truediv__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \
PyVec##D& self = _CAST(PyVec##D&, _0); \ Vec##D& self = _CAST(Vec##D&, _0); \
f64 other = CAST(f64, _1); \ f64 other = CAST(f64, _1); \
return VAR(self / other); \ return VAR(self / other); \
}); });
// https://github.com/Unity-Technologies/UnityCsReference/blob/master/Runtime/Export/Math/Vector2.cs#L289 // https://github.com/Unity-Technologies/UnityCsReference/blob/master/Runtime/Export/Math/Vector2.cs#L289
static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float smoothTime, float maxSpeed, float deltaTime) static Vec2 SmoothDamp(Vec2 current, Vec2 target, Vec2& currentVelocity, float smoothTime, float maxSpeed, float deltaTime)
{ {
// Based on Game Programming Gems 4 Chapter 1.10 // Based on Game Programming Gems 4 Chapter 1.10
smoothTime = std::max(0.0001F, smoothTime); smoothTime = std::max(0.0001F, smoothTime);
@ -105,20 +105,20 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
return Vec2(output_x, output_y); return Vec2(output_x, output_y);
} }
void PyVec2::_register(VM* vm, PyObject* mod, PyObject* type){ void Vec2::_register(VM* vm, PyObject* mod, PyObject* type){
PY_STRUCT_LIKE(PyVec2) PY_STRUCT_LIKE(Vec2)
vm->bind_constructor<3>(type, [](VM* vm, ArgsView args){ vm->bind_constructor<3>(type, [](VM* vm, ArgsView args){
float x = CAST_F(args[1]); float x = CAST_F(args[1]);
float y = CAST_F(args[2]); float y = CAST_F(args[2]);
return vm->heap.gcnew<PyVec2>(PK_OBJ_GET(Type, args[0]), Vec2(x, y)); return vm->heap.gcnew<Vec2>(PK_OBJ_GET(Type, args[0]), Vec2(x, y));
}); });
// @staticmethod // @staticmethod
vm->bind(type, "smooth_damp(current: vec2, target: vec2, current_velocity_: vec2, smooth_time: float, max_speed: float, delta_time: float) -> vec2", [](VM* vm, ArgsView args){ vm->bind(type, "smooth_damp(current: vec2, target: vec2, current_velocity_: vec2, smooth_time: float, max_speed: float, delta_time: float) -> vec2", [](VM* vm, ArgsView args){
Vec2 current = CAST(Vec2, args[0]); Vec2 current = CAST(Vec2, args[0]);
Vec2 target = CAST(Vec2, args[1]); Vec2 target = CAST(Vec2, args[1]);
PyVec2& current_velocity_ = CAST(PyVec2&, args[2]); Vec2& current_velocity_ = CAST(Vec2&, args[2]);
float smooth_time = CAST_F(args[3]); float smooth_time = CAST_F(args[3]);
float max_speed = CAST_F(args[4]); float max_speed = CAST_F(args[4]);
float delta_time = CAST_F(args[5]); float delta_time = CAST_F(args[5]);
@ -128,8 +128,8 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
// @staticmethod // @staticmethod
vm->bind(type, "angle(__from: vec2, __to: vec2) -> float", [](VM* vm, ArgsView args){ vm->bind(type, "angle(__from: vec2, __to: vec2) -> float", [](VM* vm, ArgsView args){
PyVec2 __from = CAST(PyVec2, args[0]); Vec2 __from = CAST(Vec2, args[0]);
PyVec2 __to = CAST(PyVec2, args[1]); Vec2 __to = CAST(Vec2, args[1]);
float val = atan2f(__to.y, __to.x) - atan2f(__from.y, __from.x); float val = atan2f(__to.y, __to.x) - atan2f(__from.y, __from.x);
const float PI = 3.1415926535897932384f; const float PI = 3.1415926535897932384f;
if(val > PI) val -= 2*PI; if(val > PI) val -= 2*PI;
@ -138,7 +138,7 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
}, {}, BindType::STATICMETHOD); }, {}, BindType::STATICMETHOD);
vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){ vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){
Vec2 self = _CAST(PyVec2&, obj); Vec2 self = _CAST(Vec2&, obj);
SStream ss; SStream ss;
ss.setprecision(3); ss.setprecision(3);
ss << "vec2(" << self.x << ", " << self.y << ")"; ss << "vec2(" << self.x << ", " << self.y << ")";
@ -146,20 +146,20 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
}); });
vm->bind_method<1>(type, "rotate", [](VM* vm, ArgsView args){ vm->bind_method<1>(type, "rotate", [](VM* vm, ArgsView args){
Vec2 self = _CAST(PyVec2&, args[0]); Vec2 self = _CAST(Vec2&, args[0]);
float radian = CAST(f64, args[1]); float radian = CAST(f64, args[1]);
return VAR_T(PyVec2, self.rotate(radian)); return VAR_T(Vec2, self.rotate(radian));
}); });
vm->bind_method<1>(type, "rotate_", [](VM* vm, ArgsView args){ vm->bind_method<1>(type, "rotate_", [](VM* vm, ArgsView args){
PyVec2& self = _CAST(PyVec2&, args[0]); Vec2& self = _CAST(Vec2&, args[0]);
float radian = CAST(f64, args[1]); float radian = CAST(f64, args[1]);
self = self.rotate(radian); self = self.rotate(radian);
return vm->None; return vm->None;
}); });
PY_FIELD(PyVec2, "x", _, x) PY_FIELD(Vec2, "x", _, x)
PY_FIELD(PyVec2, "y", _, y) PY_FIELD(Vec2, "y", _, y)
BIND_VEC_VEC_OP(2, __add__, +) BIND_VEC_VEC_OP(2, __add__, +)
BIND_VEC_VEC_OP(2, __sub__, -) BIND_VEC_VEC_OP(2, __sub__, -)
@ -174,27 +174,27 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
BIND_VEC_FUNCTION_0(2, normalize_) BIND_VEC_FUNCTION_0(2, normalize_)
} }
void PyVec3::_register(VM* vm, PyObject* mod, PyObject* type){ void Vec3::_register(VM* vm, PyObject* mod, PyObject* type){
PY_STRUCT_LIKE(PyVec3) PY_STRUCT_LIKE(Vec3)
vm->bind_constructor<4>(type, [](VM* vm, ArgsView args){ vm->bind_constructor<4>(type, [](VM* vm, ArgsView args){
float x = CAST_F(args[1]); float x = CAST_F(args[1]);
float y = CAST_F(args[2]); float y = CAST_F(args[2]);
float z = CAST_F(args[3]); float z = CAST_F(args[3]);
return vm->heap.gcnew<PyVec3>(PK_OBJ_GET(Type, args[0]), Vec3(x, y, z)); return vm->heap.gcnew<Vec3>(PK_OBJ_GET(Type, args[0]), Vec3(x, y, z));
}); });
vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){ vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){
Vec3 self = _CAST(PyVec3&, obj); Vec3 self = _CAST(Vec3&, obj);
SStream ss; SStream ss;
ss.setprecision(3); ss.setprecision(3);
ss << "vec3(" << self.x << ", " << self.y << ", " << self.z << ")"; ss << "vec3(" << self.x << ", " << self.y << ", " << self.z << ")";
return VAR(ss.str()); return VAR(ss.str());
}); });
PY_FIELD(PyVec3, "x", _, x) PY_FIELD(Vec3, "x", _, x)
PY_FIELD(PyVec3, "y", _, y) PY_FIELD(Vec3, "y", _, y)
PY_FIELD(PyVec3, "z", _, z) PY_FIELD(Vec3, "z", _, z)
BIND_VEC_VEC_OP(3, __add__, +) BIND_VEC_VEC_OP(3, __add__, +)
BIND_VEC_VEC_OP(3, __sub__, -) BIND_VEC_VEC_OP(3, __sub__, -)
@ -208,29 +208,29 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
BIND_VEC_FUNCTION_0(3, normalize_) BIND_VEC_FUNCTION_0(3, normalize_)
} }
void PyVec4::_register(VM* vm, PyObject* mod, PyObject* type){ void Vec4::_register(VM* vm, PyObject* mod, PyObject* type){
PY_STRUCT_LIKE(PyVec4) PY_STRUCT_LIKE(Vec4)
vm->bind_constructor<1+4>(type, [](VM* vm, ArgsView args){ vm->bind_constructor<1+4>(type, [](VM* vm, ArgsView args){
float x = CAST_F(args[1]); float x = CAST_F(args[1]);
float y = CAST_F(args[2]); float y = CAST_F(args[2]);
float z = CAST_F(args[3]); float z = CAST_F(args[3]);
float w = CAST_F(args[4]); float w = CAST_F(args[4]);
return vm->heap.gcnew<PyVec4>(PK_OBJ_GET(Type, args[0]), Vec4(x, y, z, w)); return vm->heap.gcnew<Vec4>(PK_OBJ_GET(Type, args[0]), Vec4(x, y, z, w));
}); });
vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){ vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){
Vec4 self = _CAST(PyVec4&, obj); Vec4 self = _CAST(Vec4&, obj);
SStream ss; SStream ss;
ss.setprecision(3); ss.setprecision(3);
ss << "vec4(" << self.x << ", " << self.y << ", " << self.z << ", " << self.w << ")"; ss << "vec4(" << self.x << ", " << self.y << ", " << self.z << ", " << self.w << ")";
return VAR(ss.str()); return VAR(ss.str());
}); });
PY_FIELD(PyVec4, "x", _, x) PY_FIELD(Vec4, "x", _, x)
PY_FIELD(PyVec4, "y", _, y) PY_FIELD(Vec4, "y", _, y)
PY_FIELD(PyVec4, "z", _, z) PY_FIELD(Vec4, "z", _, z)
PY_FIELD(PyVec4, "w", _, w) PY_FIELD(Vec4, "w", _, w)
BIND_VEC_VEC_OP(4, __add__, +) BIND_VEC_VEC_OP(4, __add__, +)
BIND_VEC_VEC_OP(4, __sub__, -) BIND_VEC_VEC_OP(4, __sub__, -)
@ -248,36 +248,36 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
#undef BIND_VEC_FUNCTION_0 #undef BIND_VEC_FUNCTION_0
#undef BIND_VEC_FUNCTION_1 #undef BIND_VEC_FUNCTION_1
void PyMat3x3::_register(VM* vm, PyObject* mod, PyObject* type){ void Mat3x3::_register(VM* vm, PyObject* mod, PyObject* type){
PY_STRUCT_LIKE(PyMat3x3) PY_STRUCT_LIKE(Mat3x3)
vm->bind_constructor<-1>(type, [](VM* vm, ArgsView args){ vm->bind_constructor<-1>(type, [](VM* vm, ArgsView args){
if(args.size() == 1+0) return vm->heap.gcnew<PyMat3x3>(PK_OBJ_GET(Type, args[0]), Mat3x3::zeros()); if(args.size() == 1+0) return vm->heap.gcnew<Mat3x3>(PK_OBJ_GET(Type, args[0]), Mat3x3::zeros());
if(args.size() == 1+1){ if(args.size() == 1+1){
const List& list = CAST(List&, args[1]); const List& list = CAST(List&, args[1]);
if(list.size() != 9) vm->TypeError("Mat3x3.__new__ takes a list of 9 floats"); if(list.size() != 9) vm->TypeError("Mat3x3.__new__ takes a list of 9 floats");
Mat3x3 mat; Mat3x3 mat;
for(int i=0; i<9; i++) mat.v[i] = CAST_F(list[i]); for(int i=0; i<9; i++) mat.v[i] = CAST_F(list[i]);
return vm->heap.gcnew<PyMat3x3>(PK_OBJ_GET(Type, args[0]), mat); return vm->heap.gcnew<Mat3x3>(PK_OBJ_GET(Type, args[0]), mat);
} }
if(args.size() == 1+9){ if(args.size() == 1+9){
Mat3x3 mat; Mat3x3 mat;
for(int i=0; i<9; i++) mat.v[i] = CAST_F(args[1+i]); for(int i=0; i<9; i++) mat.v[i] = CAST_F(args[1+i]);
return vm->heap.gcnew<PyMat3x3>(PK_OBJ_GET(Type, args[0]), mat); return vm->heap.gcnew<Mat3x3>(PK_OBJ_GET(Type, args[0]), mat);
} }
vm->TypeError(_S("Mat3x3.__new__ takes 0 or 1 or 9 arguments, got ", args.size()-1)); vm->TypeError(_S("Mat3x3.__new__ takes 0 or 1 or 9 arguments, got ", args.size()-1));
return vm->None; return vm->None;
}); });
vm->bind_method<1>(type, "copy_", [](VM* vm, ArgsView args){ vm->bind_method<1>(type, "copy_", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
const PyMat3x3& other = CAST(PyMat3x3&, args[1]); const Mat3x3& other = CAST(Mat3x3&, args[1]);
self = other; self = other;
return vm->None; return vm->None;
}); });
vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){ vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){
const PyMat3x3& self = _CAST(PyMat3x3&, obj); const Mat3x3& self = _CAST(Mat3x3&, obj);
SStream ss; SStream ss;
ss.setprecision(3); ss.setprecision(3);
ss << "mat3x3([" << self._11 << ", " << self._12 << ", " << self._13 << ",\n"; ss << "mat3x3([" << self._11 << ", " << self._12 << ", " << self._13 << ",\n";
@ -287,7 +287,7 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
}); });
vm->bind__getitem__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj, PyObject* index){ vm->bind__getitem__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj, PyObject* index){
PyMat3x3& self = _CAST(PyMat3x3&, obj); Mat3x3& self = _CAST(Mat3x3&, obj);
Tuple& t = CAST(Tuple&, index); Tuple& t = CAST(Tuple&, index);
if(t.size() != 2){ if(t.size() != 2){
vm->TypeError("Mat3x3.__getitem__ takes a tuple of 2 integers"); vm->TypeError("Mat3x3.__getitem__ takes a tuple of 2 integers");
@ -301,7 +301,7 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
}); });
vm->bind__setitem__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj, PyObject* index, PyObject* value){ vm->bind__setitem__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj, PyObject* index, PyObject* value){
PyMat3x3& self = _CAST(PyMat3x3&, obj); Mat3x3& self = _CAST(Mat3x3&, obj);
const Tuple& t = CAST(Tuple&, index); const Tuple& t = CAST(Tuple&, index);
if(t.size() != 2){ if(t.size() != 2){
vm->TypeError("Mat3x3.__setitem__ takes a tuple of 2 integers"); vm->TypeError("Mat3x3.__setitem__ takes a tuple of 2 integers");
@ -314,99 +314,99 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
self.m[i][j] = CAST_F(value); self.m[i][j] = CAST_F(value);
}); });
PY_FIELD(PyMat3x3, "_11", _, _11) PY_FIELD(Mat3x3, "_11", _, _11)
PY_FIELD(PyMat3x3, "_12", _, _12) PY_FIELD(Mat3x3, "_12", _, _12)
PY_FIELD(PyMat3x3, "_13", _, _13) PY_FIELD(Mat3x3, "_13", _, _13)
PY_FIELD(PyMat3x3, "_21", _, _21) PY_FIELD(Mat3x3, "_21", _, _21)
PY_FIELD(PyMat3x3, "_22", _, _22) PY_FIELD(Mat3x3, "_22", _, _22)
PY_FIELD(PyMat3x3, "_23", _, _23) PY_FIELD(Mat3x3, "_23", _, _23)
PY_FIELD(PyMat3x3, "_31", _, _31) PY_FIELD(Mat3x3, "_31", _, _31)
PY_FIELD(PyMat3x3, "_32", _, _32) PY_FIELD(Mat3x3, "_32", _, _32)
PY_FIELD(PyMat3x3, "_33", _, _33) PY_FIELD(Mat3x3, "_33", _, _33)
vm->bind__add__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ vm->bind__add__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){
PyMat3x3& self = _CAST(PyMat3x3&, _0); Mat3x3& self = _CAST(Mat3x3&, _0);
PyMat3x3& other = CAST(PyMat3x3&, _1); Mat3x3& other = CAST(Mat3x3&, _1);
return VAR_T(PyMat3x3, self + other); return VAR_T(Mat3x3, self + other);
}); });
vm->bind__sub__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ vm->bind__sub__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){
PyMat3x3& self = _CAST(PyMat3x3&, _0); Mat3x3& self = _CAST(Mat3x3&, _0);
PyMat3x3& other = CAST(PyMat3x3&, _1); Mat3x3& other = CAST(Mat3x3&, _1);
return VAR_T(PyMat3x3, self - other); return VAR_T(Mat3x3, self - other);
}); });
vm->bind__mul__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ vm->bind__mul__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){
PyMat3x3& self = _CAST(PyMat3x3&, _0); Mat3x3& self = _CAST(Mat3x3&, _0);
f64 other = CAST_F(_1); f64 other = CAST_F(_1);
return VAR_T(PyMat3x3, self * other); return VAR_T(Mat3x3, self * other);
}); });
vm->bind_method<1>(type, "__rmul__", [](VM* vm, ArgsView args){ vm->bind_method<1>(type, "__rmul__", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
f64 other = CAST_F(args[1]); f64 other = CAST_F(args[1]);
return VAR_T(PyMat3x3, self * other); return VAR_T(Mat3x3, self * other);
}); });
vm->bind__truediv__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ vm->bind__truediv__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){
PyMat3x3& self = _CAST(PyMat3x3&, _0); Mat3x3& self = _CAST(Mat3x3&, _0);
f64 other = CAST_F(_1); f64 other = CAST_F(_1);
return VAR_T(PyMat3x3, self / other); return VAR_T(Mat3x3, self / other);
}); });
vm->bind__matmul__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ vm->bind__matmul__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){
PyMat3x3& self = _CAST(PyMat3x3&, _0); Mat3x3& self = _CAST(Mat3x3&, _0);
if(is_non_tagged_type(_1, PyMat3x3::_type(vm))){ if(is_non_tagged_type(_1, Mat3x3::_type(vm))){
const PyMat3x3& other = _CAST(PyMat3x3&, _1); const Mat3x3& other = _CAST(Mat3x3&, _1);
return VAR_T(PyMat3x3, self.matmul(other)); return VAR_T(Mat3x3, self.matmul(other));
} }
if(is_non_tagged_type(_1, PyVec3::_type(vm))){ if(is_non_tagged_type(_1, Vec3::_type(vm))){
const PyVec3& other = _CAST(PyVec3&, _1); const Vec3& other = _CAST(Vec3&, _1);
return VAR_T(PyVec3, self.matmul(other)); return VAR_T(Vec3, self.matmul(other));
} }
return vm->NotImplemented; return vm->NotImplemented;
}); });
vm->bind(type, "matmul(self, other: mat3x3, out: mat3x3 = None)", [](VM* vm, ArgsView args){ vm->bind(type, "matmul(self, other: mat3x3, out: mat3x3 = None)", [](VM* vm, ArgsView args){
const PyMat3x3& self = _CAST(PyMat3x3&, args[0]); const Mat3x3& self = _CAST(Mat3x3&, args[0]);
const PyMat3x3& other = CAST(PyMat3x3&, args[1]); const Mat3x3& other = CAST(Mat3x3&, args[1]);
if(args[2] == vm->None){ if(args[2] == vm->None){
return VAR_T(PyMat3x3, self.matmul(other)); return VAR_T(Mat3x3, self.matmul(other));
}else{ }else{
PyMat3x3& out = CAST(PyMat3x3&, args[2]); Mat3x3& out = CAST(Mat3x3&, args[2]);
out = self.matmul(other); out = self.matmul(other);
return vm->None; return vm->None;
} }
}); });
vm->bind_method<0>(type, "determinant", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "determinant", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
return VAR(self.determinant()); return VAR(self.determinant());
}); });
vm->bind_method<0>(type, "transpose", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "transpose", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
return VAR_T(PyMat3x3, self.transpose()); return VAR_T(Mat3x3, self.transpose());
}); });
vm->bind__invert__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){ vm->bind__invert__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){
PyMat3x3& self = _CAST(PyMat3x3&, obj); Mat3x3& self = _CAST(Mat3x3&, obj);
Mat3x3 ret; Mat3x3 ret;
bool ok = self.inverse(ret); bool ok = self.inverse(ret);
if(!ok) vm->ValueError("matrix is not invertible"); if(!ok) vm->ValueError("matrix is not invertible");
return VAR_T(PyMat3x3, ret); return VAR_T(Mat3x3, ret);
}); });
vm->bind_method<0>(type, "invert", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "invert", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
Mat3x3 ret; Mat3x3 ret;
bool ok = self.inverse(ret); bool ok = self.inverse(ret);
if(!ok) vm->ValueError("matrix is not invertible"); if(!ok) vm->ValueError("matrix is not invertible");
return VAR_T(PyMat3x3, ret); return VAR_T(Mat3x3, ret);
}); });
vm->bind_method<0>(type, "invert_", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "invert_", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
Mat3x3 ret; Mat3x3 ret;
bool ok = self.inverse(ret); bool ok = self.inverse(ret);
if(!ok) vm->ValueError("matrix is not invertible"); if(!ok) vm->ValueError("matrix is not invertible");
@ -415,24 +415,24 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
}); });
vm->bind_method<0>(type, "transpose_", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "transpose_", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
self = self.transpose(); self = self.transpose();
return vm->None; return vm->None;
}); });
// @staticmethod // @staticmethod
vm->bind(type, "zeros()", [](VM* vm, ArgsView args){ vm->bind(type, "zeros()", [](VM* vm, ArgsView args){
return VAR_T(PyMat3x3, Mat3x3::zeros()); return VAR_T(Mat3x3, Mat3x3::zeros());
}, {}, BindType::STATICMETHOD); }, {}, BindType::STATICMETHOD);
// @staticmethod // @staticmethod
vm->bind(type, "ones()", [](VM* vm, ArgsView args){ vm->bind(type, "ones()", [](VM* vm, ArgsView args){
return VAR_T(PyMat3x3, Mat3x3::ones()); return VAR_T(Mat3x3, Mat3x3::ones());
}, {}, BindType::STATICMETHOD); }, {}, BindType::STATICMETHOD);
// @staticmethod // @staticmethod
vm->bind(type, "identity()", [](VM* vm, ArgsView args){ vm->bind(type, "identity()", [](VM* vm, ArgsView args){
return VAR_T(PyMat3x3, Mat3x3::identity()); return VAR_T(Mat3x3, Mat3x3::identity());
}, {}, BindType::STATICMETHOD); }, {}, BindType::STATICMETHOD);
/*************** affine transformations ***************/ /*************** affine transformations ***************/
@ -441,11 +441,11 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
Vec2 t = CAST(Vec2, args[0]); Vec2 t = CAST(Vec2, args[0]);
f64 r = CAST_F(args[1]); f64 r = CAST_F(args[1]);
Vec2 s = CAST(Vec2, args[2]); Vec2 s = CAST(Vec2, args[2]);
return VAR_T(PyMat3x3, Mat3x3::trs(t, r, s)); return VAR_T(Mat3x3, Mat3x3::trs(t, r, s));
}, {}, BindType::STATICMETHOD); }, {}, BindType::STATICMETHOD);
vm->bind(type, "copy_trs_(self, t: vec2, r: float, s: vec2)", [](VM* vm, ArgsView args){ vm->bind(type, "copy_trs_(self, t: vec2, r: float, s: vec2)", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
Vec2 t = CAST(Vec2, args[1]); Vec2 t = CAST(Vec2, args[1]);
f64 r = CAST_F(args[2]); f64 r = CAST_F(args[2]);
Vec2 s = CAST(Vec2, args[3]); Vec2 s = CAST(Vec2, args[3]);
@ -454,68 +454,68 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
}); });
vm->bind(type, "copy_t_(self, t: vec2)", [](VM* vm, ArgsView args){ vm->bind(type, "copy_t_(self, t: vec2)", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
Vec2 t = CAST(Vec2, args[1]); Vec2 t = CAST(Vec2, args[1]);
self = Mat3x3::trs(t, self._r(), self._s()); self = Mat3x3::trs(t, self._r(), self._s());
return vm->None; return vm->None;
}); });
vm->bind(type, "copy_r_(self, r: float)", [](VM* vm, ArgsView args){ vm->bind(type, "copy_r_(self, r: float)", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
f64 r = CAST_F(args[1]); f64 r = CAST_F(args[1]);
self = Mat3x3::trs(self._t(), r, self._s()); self = Mat3x3::trs(self._t(), r, self._s());
return vm->None; return vm->None;
}); });
vm->bind(type, "copy_s_(self, s: vec2)", [](VM* vm, ArgsView args){ vm->bind(type, "copy_s_(self, s: vec2)", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
Vec2 s = CAST(Vec2, args[1]); Vec2 s = CAST(Vec2, args[1]);
self = Mat3x3::trs(self._t(), self._r(), s); self = Mat3x3::trs(self._t(), self._r(), s);
return vm->None; return vm->None;
}); });
vm->bind_method<0>(type, "is_affine", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "is_affine", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
return VAR(self.is_affine()); return VAR(self.is_affine());
}); });
vm->bind_method<0>(type, "_t", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "_t", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
return VAR_T(PyVec2, self._t()); return VAR_T(Vec2, self._t());
}); });
vm->bind_method<0>(type, "_r", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "_r", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
return VAR(self._r()); return VAR(self._r());
}); });
vm->bind_method<0>(type, "_s", [](VM* vm, ArgsView args){ vm->bind_method<0>(type, "_s", [](VM* vm, ArgsView args){
PyMat3x3& self = _CAST(PyMat3x3&, args[0]); Mat3x3& self = _CAST(Mat3x3&, args[0]);
return VAR_T(PyVec2, self._s()); return VAR_T(Vec2, self._s());
}); });
vm->bind_method<1>(type, "transform_point", [](VM* vm, ArgsView args){ vm->bind_method<1>(type, "transform_point", [](VM* vm, ArgsView args){
const PyMat3x3& self = _CAST(PyMat3x3&, args[0]); const Mat3x3& self = _CAST(Mat3x3&, args[0]);
Vec2 v = CAST(Vec2, args[1]); Vec2 v = CAST(Vec2, args[1]);
Vec2 res = Vec2(self._11 * v.x + self._12 * v.y + self._13, self._21 * v.x + self._22 * v.y + self._23); Vec2 res = Vec2(self._11 * v.x + self._12 * v.y + self._13, self._21 * v.x + self._22 * v.y + self._23);
return VAR_T(PyVec2, res); return VAR_T(Vec2, res);
}); });
vm->bind_method<1>(type, "transform_vector", [](VM* vm, ArgsView args){ vm->bind_method<1>(type, "transform_vector", [](VM* vm, ArgsView args){
const PyMat3x3& self = _CAST(PyMat3x3&, args[0]); const Mat3x3& self = _CAST(Mat3x3&, args[0]);
Vec2 v = CAST(Vec2, args[1]); Vec2 v = CAST(Vec2, args[1]);
Vec2 res = Vec2(self._11 * v.x + self._12 * v.y, self._21 * v.x + self._22 * v.y); Vec2 res = Vec2(self._11 * v.x + self._12 * v.y, self._21 * v.x + self._22 * v.y);
return VAR_T(PyVec2, res); return VAR_T(Vec2, res);
}); });
} }
void add_module_linalg(VM* vm){ void add_module_linalg(VM* vm){
PyObject* linalg = vm->new_module("linalg"); PyObject* linalg = vm->new_module("linalg");
PyVec2::register_class(vm, linalg); Vec2::register_class(vm, linalg);
PyVec3::register_class(vm, linalg); Vec3::register_class(vm, linalg);
PyVec4::register_class(vm, linalg); Vec4::register_class(vm, linalg);
PyMat3x3::register_class(vm, linalg); Mat3x3::register_class(vm, linalg);
PyObject* float_p = vm->_modules["c"]->attr("float_p"); PyObject* float_p = vm->_modules["c"]->attr("float_p");
linalg->attr().set("vec2_p", float_p); linalg->attr().set("vec2_p", float_p);