mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-20 03:20:18 +00:00
update linalg
This commit is contained in:
blueloveTH
parent
d717f9499f
commit
019e0f974a
@ -1,25 +1,23 @@
|
||||
#pragma once
|
||||
|
||||
typedef struct c11_vec2i {
|
||||
int x;
|
||||
int y;
|
||||
typedef union c11_vec2i {
|
||||
struct { int x, y; };
|
||||
int data[2];
|
||||
} c11_vec2i;
|
||||
|
||||
typedef struct c11_vec3i {
|
||||
int x;
|
||||
int y;
|
||||
int z;
|
||||
typedef union c11_vec3i {
|
||||
struct { int x, y, z; };
|
||||
int data[3];
|
||||
} c11_vec3i;
|
||||
|
||||
typedef struct c11_vec2 {
|
||||
float x;
|
||||
float y;
|
||||
typedef union c11_vec2 {
|
||||
struct { float x, y; };
|
||||
float data[2];
|
||||
} c11_vec2;
|
||||
|
||||
typedef struct c11_vec3 {
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
typedef union c11_vec3 {
|
||||
struct { float x, y, z; };
|
||||
float data[3];
|
||||
} c11_vec3;
|
||||
|
||||
typedef union c11_mat3x3 {
|
||||
|
||||
@ -1,9 +1,23 @@
|
||||
from typing import overload
|
||||
|
||||
class vec2:
|
||||
ZERO = vec2(0, 0)
|
||||
ONE = vec2(1, 1)
|
||||
class _vecD[T]:
|
||||
ONE: T
|
||||
ZERO: T
|
||||
|
||||
def __add__(self, other: T) -> T: ...
|
||||
def __sub__(self, other: T) -> T: ...
|
||||
@overload
|
||||
def __mul__(self, other: float) -> T: ...
|
||||
@overload
|
||||
def __mul__(self, other: T) -> T: ...
|
||||
def __truediv__(self, other: float) -> T: ...
|
||||
|
||||
def dot(self, other: T) -> float: ...
|
||||
def length(self) -> float: ...
|
||||
def length_squared(self) -> float: ...
|
||||
def normalize(self) -> T: ...
|
||||
|
||||
class vec2(_vecD['vec2']):
|
||||
@property
|
||||
def x(self) -> float: ...
|
||||
@property
|
||||
@ -11,25 +25,10 @@ class vec2:
|
||||
|
||||
def with_x(self, x: float) -> vec2: ...
|
||||
def with_y(self, y: float) -> vec2: ...
|
||||
def with_z(self, z: float) -> vec3: ...
|
||||
|
||||
def __init__(self, x: float, y: float) -> None: ...
|
||||
def __repr__(self) -> str: ...
|
||||
def __eq__(self, other: vec2) -> bool: ...
|
||||
def __ne__(self, other: vec2) -> bool: ...
|
||||
|
||||
def __add__(self, other: vec2) -> vec2: ...
|
||||
def __sub__(self, other: vec2) -> vec2: ...
|
||||
@overload
|
||||
def __mul__(self, other: float) -> vec2: ...
|
||||
@overload
|
||||
def __mul__(self, other: vec2) -> vec2: ...
|
||||
def __truediv__(self, other: float) -> vec2: ...
|
||||
|
||||
def dot(self, other: vec2) -> float: ...
|
||||
def cross(self, other: vec2) -> float: ...
|
||||
def length(self) -> float: ...
|
||||
def length_squared(self) -> float: ...
|
||||
def normalize(self) -> vec2: ...
|
||||
def rotate(self, radians: float) -> vec2: ...
|
||||
|
||||
@staticmethod
|
||||
@ -52,9 +51,6 @@ class vec2:
|
||||
|
||||
class mat3x3:
|
||||
def __init__(self, _11, _12, _13, _21, _22, _23, _31, _32, _33) -> None: ...
|
||||
def __repr__(self) -> str: ...
|
||||
def __eq__(self, other: mat3x3) -> bool: ...
|
||||
def __ne__(self, other: mat3x3) -> bool: ...
|
||||
|
||||
def __getitem__(self, index: tuple[int, int]) -> float: ...
|
||||
def __setitem__(self, index: tuple[int, int], value: float) -> None: ...
|
||||
@ -104,9 +100,6 @@ class vec2i:
|
||||
def with_y(self, y: int) -> vec2i: ...
|
||||
|
||||
def __init__(self, x: int, y: int) -> None: ...
|
||||
def __repr__(self) -> str: ...
|
||||
def __eq__(self, other: vec2i) -> bool: ...
|
||||
def __ne__(self, other: vec2i) -> bool: ...
|
||||
|
||||
|
||||
class vec3i:
|
||||
@ -122,12 +115,9 @@ class vec3i:
|
||||
def with_z(self, z: int) -> vec3i: ...
|
||||
|
||||
def __init__(self, x: int, y: int, z: int) -> None: ...
|
||||
def __repr__(self) -> str: ...
|
||||
def __eq__(self, other: vec3i) -> bool: ...
|
||||
def __ne__(self, other: vec3i) -> bool: ...
|
||||
|
||||
|
||||
class vec3:
|
||||
class vec3(_vecD['vec3']):
|
||||
@property
|
||||
def x(self) -> float: ...
|
||||
@property
|
||||
@ -135,11 +125,14 @@ class vec3:
|
||||
@property
|
||||
def z(self) -> float: ...
|
||||
|
||||
@property
|
||||
def xy(self) -> vec2: ...
|
||||
|
||||
def with_x(self, x: float) -> vec3: ...
|
||||
def with_y(self, y: float) -> vec3: ...
|
||||
def with_z(self, z: float) -> vec3: ...
|
||||
|
||||
def __init__(self, x: float, y: float, z: float) -> None: ...
|
||||
def __repr__(self) -> str: ...
|
||||
def __eq__(self, other: vec3) -> bool: ...
|
||||
def __ne__(self, other: vec3) -> bool: ...
|
||||
|
||||
|
||||
|
||||
|
||||
@ -88,77 +88,152 @@ c11_mat3x3* py_tomat3x3(py_Ref self) {
|
||||
return py_touserdata(self);
|
||||
}
|
||||
|
||||
static bool vec2__new__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(3);
|
||||
py_f64 x, y;
|
||||
if(!py_castfloat(&argv[1], &x) || !py_castfloat(&argv[2], &y)) return false;
|
||||
py_newvec2(py_retval(), (c11_vec2){x, y});
|
||||
return true;
|
||||
#define DEF_VECTOR_OPS(D) \
|
||||
static bool vec##D##__new__(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(D + 1); \
|
||||
c11_vec##D res; \
|
||||
for(int i = 0; i < D; i++) { \
|
||||
if(!py_castfloat32(&argv[i + 1], &res.data[i])) return false; \
|
||||
} \
|
||||
py_newvec##D(py_retval(), res); \
|
||||
return true; \
|
||||
} \
|
||||
static bool vec##D##__add__(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(2); \
|
||||
if(argv[1].type != tp_vec##D) { \
|
||||
py_newnotimplemented(py_retval()); \
|
||||
return true; \
|
||||
} \
|
||||
c11_vec##D a = py_tovec##D(&argv[0]); \
|
||||
c11_vec##D b = py_tovec##D(&argv[1]); \
|
||||
c11_vec##D res; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
res.data[i] = a.data[i] + b.data[i]; \
|
||||
py_newvec##D(py_retval(), res); \
|
||||
return true; \
|
||||
} \
|
||||
static bool vec##D##__sub__(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(2); \
|
||||
if(argv[1].type != tp_vec##D) { \
|
||||
py_newnotimplemented(py_retval()); \
|
||||
return true; \
|
||||
} \
|
||||
c11_vec##D a = py_tovec##D(&argv[0]); \
|
||||
c11_vec##D b = py_tovec##D(&argv[1]); \
|
||||
c11_vec##D res; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
res.data[i] = a.data[i] - b.data[i]; \
|
||||
py_newvec##D(py_retval(), res); \
|
||||
return true; \
|
||||
} \
|
||||
static bool vec##D##__mul__(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(2); \
|
||||
c11_vec##D res; \
|
||||
switch(argv[1].type) { \
|
||||
case tp_vec##D: { \
|
||||
c11_vec##D a = py_tovec##D(&argv[0]); \
|
||||
c11_vec##D b = py_tovec##D(&argv[1]); \
|
||||
for(int i = 0; i < D; i++) \
|
||||
res.data[i] = a.data[i] * b.data[i]; \
|
||||
py_newvec##D(py_retval(), res); \
|
||||
return true; \
|
||||
} \
|
||||
case tp_int: { \
|
||||
c11_vec##D a = py_tovec##D(&argv[0]); \
|
||||
py_i64 b = argv[1]._i64; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
res.data[i] = a.data[i] * b; \
|
||||
py_newvec##D(py_retval(), res); \
|
||||
return true; \
|
||||
} \
|
||||
case tp_float: { \
|
||||
c11_vec##D a = py_tovec##D(&argv[0]); \
|
||||
py_f64 b = argv[1]._f64; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
res.data[i] = a.data[i] * b; \
|
||||
py_newvec##D(py_retval(), res); \
|
||||
return true; \
|
||||
} \
|
||||
default: py_newnotimplemented(py_retval()); return true; \
|
||||
} \
|
||||
} \
|
||||
static bool vec##D##__truediv__(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(2); \
|
||||
float divisor; \
|
||||
if(!py_castfloat32(&argv[1], &divisor)) { \
|
||||
py_clearexc(NULL); \
|
||||
py_newnotimplemented(py_retval()); \
|
||||
return true; \
|
||||
} \
|
||||
c11_vec##D res; \
|
||||
c11_vec##D a = py_tovec##D(&argv[0]); \
|
||||
for(int i = 0; i < D; i++) \
|
||||
res.data[i] = a.data[i] / divisor; \
|
||||
py_newvec##D(py_retval(), res); \
|
||||
return true; \
|
||||
} \
|
||||
static bool vec##D##__eq__(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(2); \
|
||||
if(argv[1].type != tp_vec##D) { \
|
||||
py_newnotimplemented(py_retval()); \
|
||||
return true; \
|
||||
} \
|
||||
c11_vec##D lhs = py_tovec##D(&argv[0]); \
|
||||
c11_vec##D rhs = py_tovec##D(&argv[1]); \
|
||||
bool ok = true; \
|
||||
for(int i = 0; i < D; i++) { \
|
||||
if(!isclose(lhs.data[i], rhs.data[i])) ok = false; \
|
||||
} \
|
||||
py_newbool(py_retval(), ok); \
|
||||
return true; \
|
||||
} \
|
||||
DEFINE_BOOL_NE(vec##D, vec##D##__eq__) \
|
||||
static bool vec##D##_length(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(1); \
|
||||
c11_vec##D v = py_tovec##D(argv); \
|
||||
float sum = 0; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
sum += v.data[i] * v.data[i]; \
|
||||
py_newfloat(py_retval(), sqrtf(sum)); \
|
||||
return true; \
|
||||
} \
|
||||
static bool vec##D##_length_squared(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(1); \
|
||||
c11_vec##D v = py_tovec##D(argv); \
|
||||
float sum = 0; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
sum += v.data[i] * v.data[i]; \
|
||||
py_newfloat(py_retval(), sum); \
|
||||
return true; \
|
||||
} \
|
||||
static bool vec##D##_dot(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(2); \
|
||||
PY_CHECK_ARG_TYPE(1, tp_vec##D); \
|
||||
c11_vec##D a = py_tovec##D(&argv[0]); \
|
||||
c11_vec##D b = py_tovec##D(&argv[1]); \
|
||||
float sum = 0; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
sum += a.data[i] * b.data[i]; \
|
||||
py_newfloat(py_retval(), sum); \
|
||||
return true; \
|
||||
} \
|
||||
static bool vec##D##_normalize(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(1); \
|
||||
c11_vec##D self = py_tovec##D(argv); \
|
||||
float len = 0; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
len += self.data[i] * self.data[i]; \
|
||||
if(isclose(len, 0)) return ZeroDivisionError("cannot normalize zero vector"); \
|
||||
len = sqrtf(len); \
|
||||
c11_vec##D res; \
|
||||
for(int i = 0; i < D; i++) \
|
||||
res.data[i] = self.data[i] / len; \
|
||||
py_newvec##D(py_retval(), res); \
|
||||
return true; \
|
||||
}
|
||||
|
||||
static bool vec2__add__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
if(argv[1].type != tp_vec2) {
|
||||
py_newnotimplemented(py_retval());
|
||||
return true;
|
||||
}
|
||||
c11_vec2 res;
|
||||
res.x = argv[0]._vec2.x + argv[1]._vec2.x;
|
||||
res.y = argv[0]._vec2.y + argv[1]._vec2.y;
|
||||
py_newvec2(py_retval(), res);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec2__sub__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
if(argv[1].type != tp_vec2) {
|
||||
py_newnotimplemented(py_retval());
|
||||
return true;
|
||||
}
|
||||
c11_vec2 res;
|
||||
res.x = argv[0]._vec2.x - argv[1]._vec2.x;
|
||||
res.y = argv[0]._vec2.y - argv[1]._vec2.y;
|
||||
py_newvec2(py_retval(), res);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec2__mul__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_vec2 res;
|
||||
switch(argv[1].type) {
|
||||
case tp_vec2:
|
||||
res.x = argv[0]._vec2.x * argv[1]._vec2.x;
|
||||
res.y = argv[0]._vec2.y * argv[1]._vec2.y;
|
||||
py_newvec2(py_retval(), res);
|
||||
return true;
|
||||
case tp_int:
|
||||
res.x = argv[0]._vec2.x * argv[1]._i64;
|
||||
res.y = argv[0]._vec2.y * argv[1]._i64;
|
||||
py_newvec2(py_retval(), res);
|
||||
return true;
|
||||
case tp_float:
|
||||
res.x = argv[0]._vec2.x * argv[1]._f64;
|
||||
res.y = argv[0]._vec2.y * argv[1]._f64;
|
||||
py_newvec2(py_retval(), res);
|
||||
return true;
|
||||
default: py_newnotimplemented(py_retval()); return true;
|
||||
}
|
||||
}
|
||||
|
||||
static bool vec2__truediv__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
float divisor;
|
||||
if(!py_castfloat32(&argv[1], &divisor)) {
|
||||
py_clearexc(NULL);
|
||||
py_newnotimplemented(py_retval());
|
||||
return true;
|
||||
}
|
||||
c11_vec2 res;
|
||||
res.x = argv[0]._vec2.x / divisor;
|
||||
res.y = argv[0]._vec2.y / divisor;
|
||||
py_newvec2(py_retval(), res);
|
||||
return true;
|
||||
}
|
||||
DEF_VECTOR_OPS(2)
|
||||
DEF_VECTOR_OPS(3)
|
||||
|
||||
static bool vec2__repr__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
@ -168,64 +243,6 @@ static bool vec2__repr__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec2__eq__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
if(argv[1].type != tp_vec2) {
|
||||
py_newnotimplemented(py_retval());
|
||||
return true;
|
||||
}
|
||||
c11_vec2 lhs = argv[0]._vec2;
|
||||
c11_vec2 rhs = argv[1]._vec2;
|
||||
py_newbool(py_retval(), isclose(lhs.x, rhs.x) && isclose(lhs.y, rhs.y));
|
||||
return true;
|
||||
}
|
||||
|
||||
DEFINE_BOOL_NE(vec2, vec2__eq__)
|
||||
|
||||
static bool vec2_dot(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
PY_CHECK_ARG_TYPE(1, tp_vec2);
|
||||
float x = argv[0]._vec2.x * argv[1]._vec2.x;
|
||||
float y = argv[0]._vec2.y * argv[1]._vec2.y;
|
||||
py_newfloat(py_retval(), x + y);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec2_cross(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
PY_CHECK_ARG_TYPE(1, tp_vec2);
|
||||
float x = argv[0]._vec2.x * argv[1]._vec2.y;
|
||||
float y = argv[0]._vec2.y * argv[1]._vec2.x;
|
||||
py_newfloat(py_retval(), x - y);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec2_length(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
float x = argv[0]._vec2.x;
|
||||
float y = argv[0]._vec2.y;
|
||||
py_newfloat(py_retval(), sqrtf(x * x + y * y));
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec2_length_squared(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
float x = argv[0]._vec2.x;
|
||||
float y = argv[0]._vec2.y;
|
||||
py_newfloat(py_retval(), x * x + y * y);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec2_normalize(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
float x = argv[0]._vec2.x;
|
||||
float y = argv[0]._vec2.y;
|
||||
float len = sqrtf(x * x + y * y);
|
||||
if(isclose(len, 0)) return ZeroDivisionError("cannot normalize zero vector");
|
||||
py_newvec2(py_retval(), (c11_vec2){x / len, y / len});
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec2_rotate(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
py_f64 radians;
|
||||
@ -318,7 +335,10 @@ static bool vec2_smoothdamp_STATIC(int argc, py_Ref argv) {
|
||||
|
||||
py_Ref ret = py_retval();
|
||||
py_newtuple(ret, 2);
|
||||
py_newvec2(py_tuple_getitem(ret, 0), (c11_vec2){output_x, output_y});
|
||||
py_newvec2(py_tuple_getitem(ret, 0),
|
||||
(c11_vec2){
|
||||
{output_x, output_y}
|
||||
});
|
||||
py_newvec2(py_tuple_getitem(ret, 1), currentVelocity);
|
||||
return true;
|
||||
}
|
||||
@ -326,6 +346,17 @@ static bool vec2_smoothdamp_STATIC(int argc, py_Ref argv) {
|
||||
DEFINE_VEC_FIELD(vec2, float, py_f64, x)
|
||||
DEFINE_VEC_FIELD(vec2, float, py_f64, y)
|
||||
|
||||
static bool vec2__with_z(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
float z;
|
||||
if(!py_castfloat32(&argv[1], &z)) return false;
|
||||
c11_vec3 v = {
|
||||
{argv->_vec2.x, argv->_vec2.y, z}
|
||||
};
|
||||
py_newvec3(py_retval(), v);
|
||||
return true;
|
||||
}
|
||||
|
||||
/* mat3x3 */
|
||||
static bool mat3x3__new__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(10);
|
||||
@ -649,7 +680,10 @@ static bool vec2i__new__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(3);
|
||||
PY_CHECK_ARG_TYPE(1, tp_int);
|
||||
PY_CHECK_ARG_TYPE(2, tp_int);
|
||||
py_newvec2i(py_retval(), (c11_vec2i){argv[1]._i64, argv[2]._i64});
|
||||
py_newvec2i(py_retval(),
|
||||
(c11_vec2i){
|
||||
{argv[1]._i64, argv[2]._i64}
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -685,7 +719,10 @@ static bool vec3i__new__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARG_TYPE(1, tp_int);
|
||||
PY_CHECK_ARG_TYPE(2, tp_int);
|
||||
PY_CHECK_ARG_TYPE(3, tp_int);
|
||||
py_newvec3i(py_retval(), (c11_vec3i){argv[1]._i64, argv[2]._i64, argv[3]._i64});
|
||||
py_newvec3i(py_retval(),
|
||||
(c11_vec3i){
|
||||
{argv[1]._i64, argv[2]._i64, argv[3]._i64}
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -717,15 +754,6 @@ DEFINE_VEC_FIELD(vec3i, int, py_i64, y)
|
||||
DEFINE_VEC_FIELD(vec3i, int, py_i64, z)
|
||||
|
||||
/* vec3 */
|
||||
static bool vec3__new__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(4);
|
||||
py_f64 x, y, z;
|
||||
if(!py_castfloat(&argv[1], &x) || !py_castfloat(&argv[2], &y) || !py_castfloat(&argv[3], &z))
|
||||
return false;
|
||||
py_newvec3(py_retval(), (c11_vec3){x, y, z});
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec3__repr__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
c11_vec3 data = py_tovec3(argv);
|
||||
@ -735,25 +763,20 @@ static bool vec3__repr__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool vec3__eq__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
if(argv[1].type != tp_vec3) {
|
||||
py_newnotimplemented(py_retval());
|
||||
return true;
|
||||
}
|
||||
c11_vec3 lhs = py_tovec3(argv);
|
||||
c11_vec3 rhs = py_tovec3(&argv[1]);
|
||||
py_newbool(py_retval(),
|
||||
isclose(lhs.x, rhs.x) && isclose(lhs.y, rhs.y) && isclose(lhs.z, rhs.z));
|
||||
return true;
|
||||
}
|
||||
|
||||
DEFINE_BOOL_NE(vec3, vec3__eq__)
|
||||
|
||||
DEFINE_VEC_FIELD(vec3, float, py_f64, x)
|
||||
DEFINE_VEC_FIELD(vec3, float, py_f64, y)
|
||||
DEFINE_VEC_FIELD(vec3, float, py_f64, z)
|
||||
|
||||
static bool vec3__xy(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
c11_vec3 data = py_tovec3(argv);
|
||||
c11_vec2 res = {
|
||||
{data.x, data.y}
|
||||
};
|
||||
py_newvec2(py_retval(), res);
|
||||
return true;
|
||||
}
|
||||
|
||||
void pk__add_module_linalg() {
|
||||
py_Ref mod = py_newmodule("linalg");
|
||||
|
||||
@ -785,14 +808,19 @@ void pk__add_module_linalg() {
|
||||
py_bindmagic(vec2, __eq__, vec2__eq__);
|
||||
py_bindmagic(vec2, __ne__, vec2__ne__);
|
||||
py_bindmethod(vec2, "dot", vec2_dot);
|
||||
py_bindmethod(vec2, "cross", vec2_cross);
|
||||
py_bindmethod(vec2, "length", vec2_length);
|
||||
py_bindmethod(vec2, "length_squared", vec2_length_squared);
|
||||
py_bindmethod(vec2, "normalize", vec2_normalize);
|
||||
py_bindmethod(vec2, "rotate", vec2_rotate);
|
||||
|
||||
py_newvec2(py_emplacedict(py_tpobject(vec2), py_name("ZERO")), (c11_vec2){0, 0});
|
||||
py_newvec2(py_emplacedict(py_tpobject(vec2), py_name("ONE")), (c11_vec2){1, 1});
|
||||
py_newvec2(py_emplacedict(py_tpobject(vec2), py_name("ZERO")),
|
||||
(c11_vec2){
|
||||
{0, 0}
|
||||
});
|
||||
py_newvec2(py_emplacedict(py_tpobject(vec2), py_name("ONE")),
|
||||
(c11_vec2){
|
||||
{1, 1}
|
||||
});
|
||||
|
||||
py_bindmethod(vec2, "angle", vec2_angle_STATIC);
|
||||
py_bindmethod(vec2, "smooth_damp", vec2_smoothdamp_STATIC);
|
||||
@ -801,6 +829,7 @@ void pk__add_module_linalg() {
|
||||
py_bindproperty(vec2, "y", vec2__y, NULL);
|
||||
py_bindmethod(vec2, "with_x", vec2__with_x);
|
||||
py_bindmethod(vec2, "with_y", vec2__with_y);
|
||||
py_bindmethod(vec2, "with_z", vec2__with_z);
|
||||
|
||||
/* mat3x3 */
|
||||
py_bindmagic(mat3x3, __new__, mat3x3__new__);
|
||||
@ -851,13 +880,31 @@ void pk__add_module_linalg() {
|
||||
|
||||
/* vec3 */
|
||||
py_bindmagic(vec3, __new__, vec3__new__);
|
||||
py_bindmagic(vec3, __add__, vec3__add__);
|
||||
py_bindmagic(vec3, __sub__, vec3__sub__);
|
||||
py_bindmagic(vec3, __mul__, vec3__mul__);
|
||||
py_bindmagic(vec3, __truediv__, vec3__truediv__);
|
||||
py_bindmagic(vec3, __repr__, vec3__repr__);
|
||||
py_bindmagic(vec3, __eq__, vec3__eq__);
|
||||
py_bindmagic(vec3, __ne__, vec3__ne__);
|
||||
py_bindmethod(vec3, "dot", vec3_dot);
|
||||
py_bindmethod(vec3, "length", vec3_length);
|
||||
py_bindmethod(vec3, "length_squared", vec3_length_squared);
|
||||
py_bindmethod(vec3, "normalize", vec3_normalize);
|
||||
py_bindproperty(vec3, "x", vec3__x, NULL);
|
||||
py_bindproperty(vec3, "y", vec3__y, NULL);
|
||||
py_bindproperty(vec3, "z", vec3__z, NULL);
|
||||
py_bindproperty(vec3, "xy", vec3__xy, NULL);
|
||||
py_bindmethod(vec3, "with_x", vec3__with_x);
|
||||
py_bindmethod(vec3, "with_y", vec3__with_y);
|
||||
py_bindmethod(vec3, "with_z", vec3__with_z);
|
||||
|
||||
py_newvec3(py_emplacedict(py_tpobject(vec3), py_name("ZERO")),
|
||||
(c11_vec3){
|
||||
{0, 0, 0}
|
||||
});
|
||||
py_newvec3(py_emplacedict(py_tpobject(vec3), py_name("ONE")),
|
||||
(c11_vec3){
|
||||
{1, 1, 1}
|
||||
});
|
||||
}
|
||||
@ -136,7 +136,10 @@ bool py_callcfunc(py_CFunction f, int argc, py_Ref argv) {
|
||||
c11__abort(
|
||||
"py_CFunction returns nothing! Did you forget to call `py_newnone(py_retval())`?");
|
||||
}
|
||||
if(py_checkexc(true)) { c11__abort("py_CFunction returns `true` but an exception is set!"); }
|
||||
if(py_checkexc(true)) {
|
||||
const char* name = py_tpname(pk_current_vm->curr_exception.type);
|
||||
c11__abort("py_CFunction returns `true`, but `%s` is set!", name);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -360,3 +360,12 @@ assert a == vec3i(1, 2, 3)
|
||||
assert a.with_x(2) == vec3i(2, 2, 3)
|
||||
assert a.with_y(3) == vec3i(1, 3, 3)
|
||||
assert a.with_z(4) == vec3i(1, 2, 4)
|
||||
|
||||
# test vec2.with_z
|
||||
assert vec2(1, 2).with_z(3) == vec3(1, 2, 3)
|
||||
# test vec3.xy
|
||||
assert vec3(1, 2, 3).xy == vec2(1, 2)
|
||||
# test vec3.ONE
|
||||
assert vec3.ONE == vec3(1, 1, 1)
|
||||
# test vec3.ZERO
|
||||
assert vec3.ZERO == vec3(0, 0, 0)
|
||||
Loading…
x
Reference in New Issue
Block a user