mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-20 11:30:18 +00:00
remove PyVec*
This commit is contained in:
blueloveTH
parent
21c2801f28
commit
d5c93c666e
@ -7,6 +7,11 @@ namespace pkpy{
|
||||
inline bool isclose(float a, float b){ return std::fabs(a - b) <= NumberTraits<4>::kEpsilon; }
|
||||
|
||||
struct Vec2{
|
||||
PY_CLASS(Vec2, linalg, vec2)
|
||||
|
||||
Vec2* _() { return this; }
|
||||
static void _register(VM* vm, PyObject* mod, PyObject* type);
|
||||
|
||||
float x, y;
|
||||
Vec2() : x(0.0f), y(0.0f) {}
|
||||
Vec2(float x, float y) : x(x), y(y) {}
|
||||
@ -30,6 +35,11 @@ struct Vec2{
|
||||
};
|
||||
|
||||
struct Vec3{
|
||||
PY_CLASS(Vec3, linalg, vec3)
|
||||
|
||||
Vec3* _() { return this; }
|
||||
static void _register(VM* vm, PyObject* mod, PyObject* type);
|
||||
|
||||
float x, y, z;
|
||||
Vec3() : x(0.0f), y(0.0f), z(0.0f) {}
|
||||
Vec3(float x, float y, float z) : x(x), y(y), z(z) {}
|
||||
@ -52,6 +62,11 @@ struct Vec3{
|
||||
};
|
||||
|
||||
struct Vec4{
|
||||
PY_CLASS(Vec4, linalg, vec4)
|
||||
|
||||
Vec4* _() { return this; }
|
||||
static void _register(VM* vm, PyObject* mod, PyObject* type);
|
||||
|
||||
float x, y, z, w;
|
||||
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) {}
|
||||
@ -72,7 +87,12 @@ struct Vec4{
|
||||
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 {
|
||||
struct {
|
||||
float _11, _12, _13;
|
||||
@ -113,74 +133,18 @@ struct Mat3x3{
|
||||
Vec2 _s() const;
|
||||
};
|
||||
|
||||
struct PyVec2: Vec2 {
|
||||
PY_CLASS(PyVec2, linalg, vec2)
|
||||
|
||||
PyVec2() : Vec2() {}
|
||||
PyVec2(const Vec2& v) : Vec2(v) {}
|
||||
Vec2* _() { return this; }
|
||||
|
||||
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); }
|
||||
inline PyObject* py_var(VM* vm, Vec2 obj){ return VAR_T(Vec2, obj); }
|
||||
inline PyObject* py_var(VM* vm, Vec3 obj){ return VAR_T(Vec3, obj); }
|
||||
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); }
|
||||
|
||||
void add_module_linalg(VM* vm);
|
||||
|
||||
static_assert(sizeof(Py_<PyMat3x3>) <= 64);
|
||||
static_assert(std::is_trivially_copyable<PyVec2>::value);
|
||||
static_assert(std::is_trivially_copyable<PyVec3>::value);
|
||||
static_assert(std::is_trivially_copyable<PyVec4>::value);
|
||||
static_assert(std::is_trivially_copyable<PyMat3x3>::value);
|
||||
static_assert(sizeof(Py_<Mat3x3>) <= 64);
|
||||
static_assert(std::is_trivially_copyable<Vec2>::value);
|
||||
static_assert(std::is_trivially_copyable<Vec3>::value);
|
||||
static_assert(std::is_trivially_copyable<Vec4>::value);
|
||||
static_assert(std::is_trivially_copyable<Mat3x3>::value);
|
||||
|
||||
} // namespace pkpy
|
||||
224
src/linalg.cpp
224
src/linalg.cpp
@ -4,54 +4,54 @@ namespace pkpy{
|
||||
|
||||
#define BIND_VEC_VEC_OP(D, name, op) \
|
||||
vm->bind##name(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \
|
||||
PyVec##D& self = _CAST(PyVec##D&, _0); \
|
||||
PyVec##D& other = CAST(PyVec##D&, _1); \
|
||||
Vec##D& self = _CAST(Vec##D&, _0); \
|
||||
Vec##D& other = CAST(Vec##D&, _1); \
|
||||
return VAR(self op other); \
|
||||
});
|
||||
|
||||
#define BIND_VEC_FLOAT_OP(D, name, op) \
|
||||
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); \
|
||||
return VAR(self op other); \
|
||||
});
|
||||
|
||||
#define BIND_VEC_FUNCTION_0(D, name) \
|
||||
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()); \
|
||||
});
|
||||
|
||||
#define BIND_VEC_FUNCTION_1(D, name) \
|
||||
vm->bind_method<1>(type, #name, [](VM* vm, ArgsView args){ \
|
||||
PyVec##D& self = _CAST(PyVec##D&, args[0]); \
|
||||
PyVec##D& other = CAST(PyVec##D&, args[1]); \
|
||||
Vec##D& self = _CAST(Vec##D&, args[0]); \
|
||||
Vec##D& other = CAST(Vec##D&, args[1]); \
|
||||
return VAR(self.name(other)); \
|
||||
});
|
||||
|
||||
#define BIND_VEC_MUL_OP(D) \
|
||||
vm->bind__mul__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ \
|
||||
PyVec##D& self = _CAST(PyVec##D&, _0); \
|
||||
if(is_non_tagged_type(_1, PyVec##D::_type(vm))){ \
|
||||
PyVec##D& other = _CAST(PyVec##D&, _1); \
|
||||
Vec##D& self = _CAST(Vec##D&, _0); \
|
||||
if(is_non_tagged_type(_1, Vec##D::_type(vm))){ \
|
||||
Vec##D& other = _CAST(Vec##D&, _1); \
|
||||
return VAR(self * other); \
|
||||
} \
|
||||
f64 other = CAST(f64, _1); \
|
||||
return VAR(self * other); \
|
||||
}); \
|
||||
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]); \
|
||||
return VAR(self * other); \
|
||||
}); \
|
||||
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); \
|
||||
return VAR(self / other); \
|
||||
});
|
||||
|
||||
// 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
|
||||
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);
|
||||
}
|
||||
|
||||
void PyVec2::_register(VM* vm, PyObject* mod, PyObject* type){
|
||||
PY_STRUCT_LIKE(PyVec2)
|
||||
void Vec2::_register(VM* vm, PyObject* mod, PyObject* type){
|
||||
PY_STRUCT_LIKE(Vec2)
|
||||
|
||||
vm->bind_constructor<3>(type, [](VM* vm, ArgsView args){
|
||||
float x = CAST_F(args[1]);
|
||||
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
|
||||
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 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 max_speed = CAST_F(args[4]);
|
||||
float delta_time = CAST_F(args[5]);
|
||||
@ -128,8 +128,8 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
|
||||
|
||||
// @staticmethod
|
||||
vm->bind(type, "angle(__from: vec2, __to: vec2) -> float", [](VM* vm, ArgsView args){
|
||||
PyVec2 __from = CAST(PyVec2, args[0]);
|
||||
PyVec2 __to = CAST(PyVec2, args[1]);
|
||||
Vec2 __from = CAST(Vec2, args[0]);
|
||||
Vec2 __to = CAST(Vec2, args[1]);
|
||||
float val = atan2f(__to.y, __to.x) - atan2f(__from.y, __from.x);
|
||||
const float PI = 3.1415926535897932384f;
|
||||
if(val > PI) val -= 2*PI;
|
||||
@ -138,7 +138,7 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
|
||||
}, {}, BindType::STATICMETHOD);
|
||||
|
||||
vm->bind__repr__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){
|
||||
Vec2 self = _CAST(PyVec2&, obj);
|
||||
Vec2 self = _CAST(Vec2&, obj);
|
||||
SStream ss;
|
||||
ss.setprecision(3);
|
||||
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){
|
||||
Vec2 self = _CAST(PyVec2&, args[0]);
|
||||
Vec2 self = _CAST(Vec2&, args[0]);
|
||||
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){
|
||||
PyVec2& self = _CAST(PyVec2&, args[0]);
|
||||
Vec2& self = _CAST(Vec2&, args[0]);
|
||||
float radian = CAST(f64, args[1]);
|
||||
self = self.rotate(radian);
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
PY_FIELD(PyVec2, "x", _, x)
|
||||
PY_FIELD(PyVec2, "y", _, y)
|
||||
PY_FIELD(Vec2, "x", _, x)
|
||||
PY_FIELD(Vec2, "y", _, y)
|
||||
|
||||
BIND_VEC_VEC_OP(2, __add__, +)
|
||||
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_)
|
||||
}
|
||||
|
||||
void PyVec3::_register(VM* vm, PyObject* mod, PyObject* type){
|
||||
PY_STRUCT_LIKE(PyVec3)
|
||||
void Vec3::_register(VM* vm, PyObject* mod, PyObject* type){
|
||||
PY_STRUCT_LIKE(Vec3)
|
||||
|
||||
vm->bind_constructor<4>(type, [](VM* vm, ArgsView args){
|
||||
float x = CAST_F(args[1]);
|
||||
float y = CAST_F(args[2]);
|
||||
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){
|
||||
Vec3 self = _CAST(PyVec3&, obj);
|
||||
Vec3 self = _CAST(Vec3&, obj);
|
||||
SStream ss;
|
||||
ss.setprecision(3);
|
||||
ss << "vec3(" << self.x << ", " << self.y << ", " << self.z << ")";
|
||||
return VAR(ss.str());
|
||||
});
|
||||
|
||||
PY_FIELD(PyVec3, "x", _, x)
|
||||
PY_FIELD(PyVec3, "y", _, y)
|
||||
PY_FIELD(PyVec3, "z", _, z)
|
||||
PY_FIELD(Vec3, "x", _, x)
|
||||
PY_FIELD(Vec3, "y", _, y)
|
||||
PY_FIELD(Vec3, "z", _, z)
|
||||
|
||||
BIND_VEC_VEC_OP(3, __add__, +)
|
||||
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_)
|
||||
}
|
||||
|
||||
void PyVec4::_register(VM* vm, PyObject* mod, PyObject* type){
|
||||
PY_STRUCT_LIKE(PyVec4)
|
||||
void Vec4::_register(VM* vm, PyObject* mod, PyObject* type){
|
||||
PY_STRUCT_LIKE(Vec4)
|
||||
|
||||
vm->bind_constructor<1+4>(type, [](VM* vm, ArgsView args){
|
||||
float x = CAST_F(args[1]);
|
||||
float y = CAST_F(args[2]);
|
||||
float z = CAST_F(args[3]);
|
||||
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){
|
||||
Vec4 self = _CAST(PyVec4&, obj);
|
||||
Vec4 self = _CAST(Vec4&, obj);
|
||||
SStream ss;
|
||||
ss.setprecision(3);
|
||||
ss << "vec4(" << self.x << ", " << self.y << ", " << self.z << ", " << self.w << ")";
|
||||
return VAR(ss.str());
|
||||
});
|
||||
|
||||
PY_FIELD(PyVec4, "x", _, x)
|
||||
PY_FIELD(PyVec4, "y", _, y)
|
||||
PY_FIELD(PyVec4, "z", _, z)
|
||||
PY_FIELD(PyVec4, "w", _, w)
|
||||
PY_FIELD(Vec4, "x", _, x)
|
||||
PY_FIELD(Vec4, "y", _, y)
|
||||
PY_FIELD(Vec4, "z", _, z)
|
||||
PY_FIELD(Vec4, "w", _, w)
|
||||
|
||||
BIND_VEC_VEC_OP(4, __add__, +)
|
||||
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_1
|
||||
|
||||
void PyMat3x3::_register(VM* vm, PyObject* mod, PyObject* type){
|
||||
PY_STRUCT_LIKE(PyMat3x3)
|
||||
void Mat3x3::_register(VM* vm, PyObject* mod, PyObject* type){
|
||||
PY_STRUCT_LIKE(Mat3x3)
|
||||
|
||||
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){
|
||||
const List& list = CAST(List&, args[1]);
|
||||
if(list.size() != 9) vm->TypeError("Mat3x3.__new__ takes a list of 9 floats");
|
||||
Mat3x3 mat;
|
||||
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){
|
||||
Mat3x3 mat;
|
||||
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));
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
vm->bind_method<1>(type, "copy_", [](VM* vm, ArgsView args){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
const PyMat3x3& other = CAST(PyMat3x3&, args[1]);
|
||||
Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
const Mat3x3& other = CAST(Mat3x3&, args[1]);
|
||||
self = other;
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
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;
|
||||
ss.setprecision(3);
|
||||
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){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, obj);
|
||||
Mat3x3& self = _CAST(Mat3x3&, obj);
|
||||
Tuple& t = CAST(Tuple&, index);
|
||||
if(t.size() != 2){
|
||||
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){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, obj);
|
||||
Mat3x3& self = _CAST(Mat3x3&, obj);
|
||||
const Tuple& t = CAST(Tuple&, index);
|
||||
if(t.size() != 2){
|
||||
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);
|
||||
});
|
||||
|
||||
PY_FIELD(PyMat3x3, "_11", _, _11)
|
||||
PY_FIELD(PyMat3x3, "_12", _, _12)
|
||||
PY_FIELD(PyMat3x3, "_13", _, _13)
|
||||
PY_FIELD(PyMat3x3, "_21", _, _21)
|
||||
PY_FIELD(PyMat3x3, "_22", _, _22)
|
||||
PY_FIELD(PyMat3x3, "_23", _, _23)
|
||||
PY_FIELD(PyMat3x3, "_31", _, _31)
|
||||
PY_FIELD(PyMat3x3, "_32", _, _32)
|
||||
PY_FIELD(PyMat3x3, "_33", _, _33)
|
||||
PY_FIELD(Mat3x3, "_11", _, _11)
|
||||
PY_FIELD(Mat3x3, "_12", _, _12)
|
||||
PY_FIELD(Mat3x3, "_13", _, _13)
|
||||
PY_FIELD(Mat3x3, "_21", _, _21)
|
||||
PY_FIELD(Mat3x3, "_22", _, _22)
|
||||
PY_FIELD(Mat3x3, "_23", _, _23)
|
||||
PY_FIELD(Mat3x3, "_31", _, _31)
|
||||
PY_FIELD(Mat3x3, "_32", _, _32)
|
||||
PY_FIELD(Mat3x3, "_33", _, _33)
|
||||
|
||||
vm->bind__add__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, _0);
|
||||
PyMat3x3& other = CAST(PyMat3x3&, _1);
|
||||
return VAR_T(PyMat3x3, self + other);
|
||||
Mat3x3& self = _CAST(Mat3x3&, _0);
|
||||
Mat3x3& other = CAST(Mat3x3&, _1);
|
||||
return VAR_T(Mat3x3, self + other);
|
||||
});
|
||||
|
||||
vm->bind__sub__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, _0);
|
||||
PyMat3x3& other = CAST(PyMat3x3&, _1);
|
||||
return VAR_T(PyMat3x3, self - other);
|
||||
Mat3x3& self = _CAST(Mat3x3&, _0);
|
||||
Mat3x3& other = CAST(Mat3x3&, _1);
|
||||
return VAR_T(Mat3x3, self - other);
|
||||
});
|
||||
|
||||
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);
|
||||
return VAR_T(PyMat3x3, self * other);
|
||||
return VAR_T(Mat3x3, self * other);
|
||||
});
|
||||
|
||||
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]);
|
||||
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){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, _0);
|
||||
Mat3x3& self = _CAST(Mat3x3&, _0);
|
||||
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){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, _0);
|
||||
if(is_non_tagged_type(_1, PyMat3x3::_type(vm))){
|
||||
const PyMat3x3& other = _CAST(PyMat3x3&, _1);
|
||||
return VAR_T(PyMat3x3, self.matmul(other));
|
||||
Mat3x3& self = _CAST(Mat3x3&, _0);
|
||||
if(is_non_tagged_type(_1, Mat3x3::_type(vm))){
|
||||
const Mat3x3& other = _CAST(Mat3x3&, _1);
|
||||
return VAR_T(Mat3x3, self.matmul(other));
|
||||
}
|
||||
if(is_non_tagged_type(_1, PyVec3::_type(vm))){
|
||||
const PyVec3& other = _CAST(PyVec3&, _1);
|
||||
return VAR_T(PyVec3, self.matmul(other));
|
||||
if(is_non_tagged_type(_1, Vec3::_type(vm))){
|
||||
const Vec3& other = _CAST(Vec3&, _1);
|
||||
return VAR_T(Vec3, self.matmul(other));
|
||||
}
|
||||
return vm->NotImplemented;
|
||||
});
|
||||
|
||||
vm->bind(type, "matmul(self, other: mat3x3, out: mat3x3 = None)", [](VM* vm, ArgsView args){
|
||||
const PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
const PyMat3x3& other = CAST(PyMat3x3&, args[1]);
|
||||
const Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
const Mat3x3& other = CAST(Mat3x3&, args[1]);
|
||||
if(args[2] == vm->None){
|
||||
return VAR_T(PyMat3x3, self.matmul(other));
|
||||
return VAR_T(Mat3x3, self.matmul(other));
|
||||
}else{
|
||||
PyMat3x3& out = CAST(PyMat3x3&, args[2]);
|
||||
Mat3x3& out = CAST(Mat3x3&, args[2]);
|
||||
out = self.matmul(other);
|
||||
return vm->None;
|
||||
}
|
||||
});
|
||||
|
||||
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());
|
||||
});
|
||||
|
||||
vm->bind_method<0>(type, "transpose", [](VM* vm, ArgsView args){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
return VAR_T(PyMat3x3, self.transpose());
|
||||
Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
return VAR_T(Mat3x3, self.transpose());
|
||||
});
|
||||
|
||||
vm->bind__invert__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, obj);
|
||||
Mat3x3& self = _CAST(Mat3x3&, obj);
|
||||
Mat3x3 ret;
|
||||
bool ok = self.inverse(ret);
|
||||
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){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
Mat3x3 ret;
|
||||
bool ok = self.inverse(ret);
|
||||
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){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
Mat3x3 ret;
|
||||
bool ok = self.inverse(ret);
|
||||
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){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
self = self.transpose();
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
// @staticmethod
|
||||
vm->bind(type, "zeros()", [](VM* vm, ArgsView args){
|
||||
return VAR_T(PyMat3x3, Mat3x3::zeros());
|
||||
return VAR_T(Mat3x3, Mat3x3::zeros());
|
||||
}, {}, BindType::STATICMETHOD);
|
||||
|
||||
// @staticmethod
|
||||
vm->bind(type, "ones()", [](VM* vm, ArgsView args){
|
||||
return VAR_T(PyMat3x3, Mat3x3::ones());
|
||||
return VAR_T(Mat3x3, Mat3x3::ones());
|
||||
}, {}, BindType::STATICMETHOD);
|
||||
|
||||
// @staticmethod
|
||||
vm->bind(type, "identity()", [](VM* vm, ArgsView args){
|
||||
return VAR_T(PyMat3x3, Mat3x3::identity());
|
||||
return VAR_T(Mat3x3, Mat3x3::identity());
|
||||
}, {}, BindType::STATICMETHOD);
|
||||
|
||||
/*************** affine transformations ***************/
|
||||
@ -441,11 +441,11 @@ static Vec2 SmoothDamp(Vec2 current, Vec2 target, PyVec2& currentVelocity, float
|
||||
Vec2 t = CAST(Vec2, args[0]);
|
||||
f64 r = CAST_F(args[1]);
|
||||
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);
|
||||
|
||||
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]);
|
||||
f64 r = CAST_F(args[2]);
|
||||
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){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
Vec2 t = CAST(Vec2, args[1]);
|
||||
self = Mat3x3::trs(t, self._r(), self._s());
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
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]);
|
||||
self = Mat3x3::trs(self._t(), r, self._s());
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
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]);
|
||||
self = Mat3x3::trs(self._t(), self._r(), s);
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
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());
|
||||
});
|
||||
|
||||
vm->bind_method<0>(type, "_t", [](VM* vm, ArgsView args){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
return VAR_T(PyVec2, self._t());
|
||||
Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
return VAR_T(Vec2, self._t());
|
||||
});
|
||||
|
||||
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());
|
||||
});
|
||||
|
||||
vm->bind_method<0>(type, "_s", [](VM* vm, ArgsView args){
|
||||
PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
return VAR_T(PyVec2, self._s());
|
||||
Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
return VAR_T(Vec2, self._s());
|
||||
});
|
||||
|
||||
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 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){
|
||||
const PyMat3x3& self = _CAST(PyMat3x3&, args[0]);
|
||||
const Mat3x3& self = _CAST(Mat3x3&, args[0]);
|
||||
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);
|
||||
return VAR_T(PyVec2, res);
|
||||
return VAR_T(Vec2, res);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
void add_module_linalg(VM* vm){
|
||||
PyObject* linalg = vm->new_module("linalg");
|
||||
PyVec2::register_class(vm, linalg);
|
||||
PyVec3::register_class(vm, linalg);
|
||||
PyVec4::register_class(vm, linalg);
|
||||
PyMat3x3::register_class(vm, linalg);
|
||||
Vec2::register_class(vm, linalg);
|
||||
Vec3::register_class(vm, linalg);
|
||||
Vec4::register_class(vm, linalg);
|
||||
Mat3x3::register_class(vm, linalg);
|
||||
|
||||
PyObject* float_p = vm->_modules["c"]->attr("float_p");
|
||||
linalg->attr().set("vec2_p", float_p);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user