From fe64c2d5be98eb1783a116b1905dcd375b60227c Mon Sep 17 00:00:00 2001 From: blueloveTH Date: Wed, 23 Aug 2023 20:55:42 +0800 Subject: [PATCH] ... --- docs/modules/box2d.md | 100 +-------------------- docs/modules/c.md | 147 +------------------------------ docs/modules/linalg.md | 124 +------------------------- include/typings/box2d.pyi | 97 ++++++++++++++++++++ include/{ => typings}/c.pyi | 0 include/{ => typings}/easing.pyi | 0 include/{ => typings}/linalg.pyi | 14 ++- src/linalg.cpp | 74 +++++++--------- 8 files changed, 136 insertions(+), 420 deletions(-) create mode 100644 include/typings/box2d.pyi rename include/{ => typings}/c.pyi (100%) rename include/{ => typings}/easing.pyi (100%) rename include/{ => typings}/linalg.pyi (95%) diff --git a/docs/modules/box2d.md b/docs/modules/box2d.md index 784dd136..e43277e8 100644 --- a/docs/modules/box2d.md +++ b/docs/modules/box2d.md @@ -42,105 +42,7 @@ It hides the details of Box2D's API and provides a high-level interface. ## API list -```python -from linalg import vec2, vec4 -from typing import Iterable - -class _NodeLike: # duck-type protocol - def on_contact_begin(self, other: 'Body'): ... - def on_contact_end(self, other: 'Body'): ... - -class _DrawLike: # duck-type protocol - def draw_polygon(self, vertices: list[vec2], color: vec4): ... - def draw_solid_polygon(self, vertices: list[vec2], color: vec4): ... - def draw_circle(self, center: vec2, radius: float, color: vec4): ... - def draw_solid_circle(self, center: vec2, radius: float, axis: vec2, color: vec4): ... - def draw_segment(self, p1: vec2, p2: vec2, color: vec4): ... - def draw_transform(self, position: vec2, rotation: float): ... - def draw_point(self, p: vec2, size: float, color: vec4): ... - -class World: - gravity: vec2 # gravity of the world, by default vec2(0, 0) - - def get_bodies(self) -> Iterable['Body']: - """return all bodies in the world.""" - - def ray_cast(self, start: vec2, end: vec2) -> list['Body']: - """raycast from start to end""" - - def box_cast(self, lower: vec2, upper: vec2) -> list['Body']: - """query bodies in the AABB region.""" - - def step(self, dt: float, velocity_iterations: int, position_iterations: int) -> None: - """step the simulation, e.g. world.step(1/60, 8, 3)""" - - # enum - # { - # e_shapeBit = 0x0001, ///< draw shapes - # e_jointBit = 0x0002, ///< draw joint connections - # e_aabbBit = 0x0004, ///< draw axis aligned bounding boxes - # e_pairBit = 0x0008, ///< draw broad-phase pairs - # e_centerOfMassBit = 0x0010 ///< draw center of mass frame - # }; - def debug_draw(self, flags: int): - """draw debug shapes of all bodies in the world.""" - - def set_debug_draw(self, draw: _DrawLike): - """set the debug draw object.""" - - def create_weld_joint(self, body_a: 'Body', body_b: 'Body'): - """create a weld joint between two bodies.""" - -class Body: - type: int # 0-static, 1-kinematic, 2-dynamic, by default 2 - gravity_scale: float - fixed_rotation: bool - enabled: bool - bullet: bool # whether to use continuous collision detection - - @property - def mass(self) -> float: ... - @property - def inertia(self) -> float: ... - - position: vec2 - rotation: float # in radians (counter-clockwise) - velocity: vec2 # linear velocity - angular_velocity: float - damping: float # linear damping - angular_damping: float - - # fixture settings - density: float - friction: float - restitution: float - restitution_threshold: float - is_sensor: bool - - def __new__(cls, world: World, node: _NodeLike = None): - """create a body in the world.""" - - def set_box_shape(self, hx: float, hy: float): ... - def set_circle_shape(self, radius: float): ... - def set_polygon_shape(self, points: list[vec2]): ... - def set_chain_shape(self, points: list[vec2]): ... - - def apply_force(self, force: vec2, point: vec2): ... - def apply_force_to_center(self, force: vec2): ... - def apply_torque(self, torque: float): ... - def apply_impulse(self, impulse: vec2, point: vec2): ... - def apply_impulse_to_center(self, impulse: vec2): ... - def apply_angular_impulse(self, impulse: float): ... - - def get_node(self) -> _NodeLike: - """return the node that is attached to this body.""" - - def get_contacts(self) -> list['Body']: - """return all bodies that are in contact with this body.""" - - def destroy(self): - """destroy this body.""" -``` +... ## Example diff --git a/docs/modules/c.md b/docs/modules/c.md index e04481a3..435d3817 100644 --- a/docs/modules/c.md +++ b/docs/modules/c.md @@ -3,149 +3,4 @@ icon: package label: c --- -Interop with pointers and C structs. - -```python -from typing import overload - -def malloc(size: int) -> 'void_p': ... -def free(ptr: 'void_p') -> None: ... -def sizeof(type: str) -> int: ... -def refl(name: str) -> '_refl': ... -def memset(ptr: 'void_p', value: int, size: int) -> None: ... -def memcpy(dst: 'void_p', src: 'void_p', size: int) -> None: ... - -class _refl: - def __call__(self) -> 'struct': ... - def __getitem__(self, key: str) -> int: ... - def name(self) -> str: ... - def size(self) -> int: ... - -class void_p: - def __add__(self, i: int) -> 'void_p': ... - def __sub__(self, i: int) -> 'void_p': ... - def __eq__(self, other: 'void_p') -> bool: ... - def __ne__(self, other: 'void_p') -> bool: ... - def offset(self, i: int) -> 'void_p': ... - - def hex(self) -> str: ... - @staticmethod - def from_hex(s: str) -> 'void_p': ... - - def read_char(self) -> int: ... - def read_uchar(self) -> int: ... - def read_short(self) -> int: ... - def read_ushort(self) -> int: ... - def read_int(self) -> int: ... - def read_uint(self) -> int: ... - def read_long(self) -> int: ... - def read_ulong(self) -> int: ... - def read_longlong(self) -> int: ... - def read_ulonglong(self) -> int: ... - def read_float(self) -> float: ... - def read_double(self) -> float: ... - def read_bool(self) -> bool: ... - def read_void_p(self) -> 'void_p': ... - def read_bytes(self, size: int) -> bytes: ... - def read_struct(self, type: str) -> 'struct': ... - - def write_char(self, value: int) -> None: ... - def write_uchar(self, value: int) -> None: ... - def write_short(self, value: int) -> None: ... - def write_ushort(self, value: int) -> None: ... - def write_int(self, value: int) -> None: ... - def write_uint(self, value: int) -> None: ... - def write_long(self, value: int) -> None: ... - def write_ulong(self, value: int) -> None: ... - def write_longlong(self, value: int) -> None: ... - def write_ulonglong(self, value: int) -> None: ... - def write_float(self, value: float) -> None: ... - def write_double(self, value: float) -> None: ... - def write_bool(self, value: bool) -> None: ... - def write_void_p(self, value: 'void_p') -> None: ... - def write_bytes(self, value: bytes) -> None: ... - def write_struct(self, value: 'struct') -> None: ... - - def get_base_offset(self) -> int: ... - @overload - def set_base_offset(self, offset: int) -> None: ... - @overload - def set_base_offset(self, offset: str) -> None: ... - -class struct: - @overload - def __init__(self, size: int): ... - @overload - def __init__(self, p: 'void_p', size: int): ... - @overload - def __init__(self, s: str): ... - @overload - def __init__(self, b: bytes): ... - - def addr(self) -> 'void_p': ... - def copy(self) -> 'struct': ... - def size(self) -> int: ... - def __eq__(self, other: 'struct') -> bool: ... - def __ne__(self, other: 'struct') -> bool: ... - - def to_string(self) -> str: ... - def to_bytes(self) -> bytes: ... - - def read_char(self, offset=0) -> int: ... - def read_uchar(self, offset=0) -> int: ... - def read_short(self, offset=0) -> int: ... - def read_ushort(self, offset=0) -> int: ... - def read_int(self, offset=0) -> int: ... - def read_uint(self, offset=0) -> int: ... - def read_long(self, offset=0) -> int: ... - def read_ulong(self, offset=0) -> int: ... - def read_longlong(self, offset=0) -> int: ... - def read_ulonglong(self, offset=0) -> int: ... - def read_float(self, offset=0) -> float: ... - def read_double(self, offset=0) -> float: ... - def read_bool(self, offset=0) -> bool: ... - def read_void_p(self, offset=0) -> 'void_p': ... - - def write_char(self, value: int, offset=0) -> None: ... - def write_uchar(self, value: int, offset=0) -> None: ... - def write_short(self, value: int, offset=0) -> None: ... - def write_ushort(self, value: int, offset=0) -> None: ... - def write_int(self, value: int, offset=0) -> None: ... - def write_uint(self, value: int, offset=0) -> None: ... - def write_long(self, value: int, offset=0) -> None: ... - def write_ulong(self, value: int, offset=0) -> None: ... - def write_longlong(self, value: int, offset=0) -> None: ... - def write_ulonglong(self, value: int, offset=0) -> None: ... - def write_float(self, value: float, offset=0) -> None: ... - def write_double(self, value: float, offset=0) -> None: ... - def write_bool(self, value: bool, offset=0) -> None: ... - def write_void_p(self, value: 'void_p', offset=0) -> None: ... - -char_ = refl("char") -uchar_ = refl("uchar") -short_ = refl("short") -ushort_ = refl("ushort") -int_ = refl("int") -uint_ = refl("uint") -long_ = refl("long") -ulong_ = refl("ulong") -longlong_ = refl("longlong") -ulonglong_ = refl("ulonglong") -float_ = refl("float") -double_ = refl("double") -bool_ = refl("bool") - -char_p = void_p -uchar_p = void_p -short_p = void_p -ushort_p = void_p -int_p = void_p -uint_p = void_p -long_p = void_p -ulong_p = void_p -longlong_p = void_p -ulonglong_p = void_p -float_p = void_p -double_p = void_p -bool_p = void_p -``` \ No newline at end of file +Interop with pointers and C structs. \ No newline at end of file diff --git a/docs/modules/linalg.md b/docs/modules/linalg.md index 68c58145..57cbf1b3 100644 --- a/docs/modules/linalg.md +++ b/docs/modules/linalg.md @@ -3,126 +3,4 @@ icon: package label: linalg --- -Provide `mat3x3`, `vec2`, `vec3` and `vec4` types. - -```python -from typing import overload -from c import float_p - -class vec2: - x: float - y: float - - def __init__(self, x: float, y: float) -> None: ... - def copy(self) -> vec2: ... - def __add__(self, other: vec2) -> vec2: ... - def __sub__(self, other: vec2) -> vec2: ... - def __mul__(self, other: float) -> 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: ... - def addr(self) -> float_p: ... - -class vec3: - x: float - y: float - z: float - - def __init__(self, x: float, y: float, z: float) -> None: ... - def copy(self) -> vec3: ... - def __add__(self, other: vec3) -> vec3: ... - def __sub__(self, other: vec3) -> vec3: ... - def __mul__(self, other: float) -> vec3: ... - def __truediv__(self, other: float) -> vec3: ... - def dot(self, other: vec3) -> float: ... - def cross(self, other: vec3) -> float: ... - def length(self) -> float: ... - def length_squared(self) -> float: ... - def normalize(self) -> vec3: ... - def addr(self) -> float_p: ... - -class vec4: - x: float - y: float - z: float - w: float - - def __init__(self, x: float, y: float, z: float, w: float) -> None: ... - def copy(self) -> vec4: ... - def __add__(self, other: vec4) -> vec4: ... - def __sub__(self, other: vec4) -> vec4: ... - def __mul__(self, other: float) -> vec4: ... - def __truediv__(self, other: float) -> vec4: ... - def dot(self, other: vec4) -> float: ... - def length(self) -> float: ... - def length_squared(self) -> float: ... - def normalize(self) -> vec4: ... - def addr(self) -> float_p: ... - -class mat3x3: - _11: float - _12: float - _13: float - _21: float - _22: float - _23: float - _31: float - _32: float - _33: float - - @overload - def __init__(self) -> None: ... - @overload - def __init__(self, _11, _12, _13, _21, _22, _23, _31, _32, _33) -> None: ... - @overload - def __init__(self, a: list[list]): ... - - def set_zeros(self) -> None: ... - def set_ones(self) -> None: ... - def set_identity(self) -> None: ... - - def copy(self) -> mat3x3: ... - def __getitem__(self, index: tuple[int, int]) -> float: ... - def __setitem__(self, index: tuple[int, int], value: float) -> None: ... - def __add__(self, other: mat3x3) -> mat3x3: ... - def __sub__(self, other: mat3x3) -> mat3x3: ... - def __mul__(self, other: float) -> mat3x3: ... - def __truediv__(self, other: float) -> mat3x3: ... - @overload - def __matmul__(self, other: mat3x3) -> mat3x3: ... - @overload - def __matmul__(self, other: vec3) -> vec3: ... - @overload - def matmul(self, other: mat3x3) -> mat3x3: ... - @overload - def matmul(self, other: vec3) -> vec3: ... - def determinant(self) -> float: ... - def transpose(self) -> mat3x3: ... - def inverse(self) -> mat3x3: ... - - def __invert__(self) -> mat3x3: ... - - @staticmethod - def zeros() -> mat3x3: ... - @staticmethod - def ones() -> mat3x3: ... - @staticmethod - def identity() -> mat3x3: ... - - # affine transformations - @staticmethod - def trs(t: vec2, r: float, s: vec2) -> mat3x3: ... - - def is_affine(self) -> bool: ... - - def translation(self) -> vec2: ... - def rotation(self) -> float: ... - def scale(self) -> vec2: ... - - def transform_point(self, p: vec2) -> vec2: ... - def transform_vector(self, v: vec2) -> vec2: ... -``` \ No newline at end of file +Provide `mat3x3`, `vec2`, `vec3` and `vec4` types. \ No newline at end of file diff --git a/include/typings/box2d.pyi b/include/typings/box2d.pyi new file mode 100644 index 00000000..abd19b62 --- /dev/null +++ b/include/typings/box2d.pyi @@ -0,0 +1,97 @@ +from linalg import vec2, vec4 +from typing import Iterable + +class _NodeLike: # duck-type protocol + def on_contact_begin(self, other: 'Body'): ... + def on_contact_end(self, other: 'Body'): ... + +class _DrawLike: # duck-type protocol + def draw_polygon(self, vertices: list[vec2], color: vec4): ... + def draw_solid_polygon(self, vertices: list[vec2], color: vec4): ... + def draw_circle(self, center: vec2, radius: float, color: vec4): ... + def draw_solid_circle(self, center: vec2, radius: float, axis: vec2, color: vec4): ... + def draw_segment(self, p1: vec2, p2: vec2, color: vec4): ... + def draw_transform(self, position: vec2, rotation: float): ... + def draw_point(self, p: vec2, size: float, color: vec4): ... + +class World: + gravity: vec2 # gravity of the world, by default vec2(0, 0) + + def get_bodies(self) -> Iterable['Body']: + """return all bodies in the world.""" + + def ray_cast(self, start: vec2, end: vec2) -> list['Body']: + """raycast from start to end""" + + def box_cast(self, lower: vec2, upper: vec2) -> list['Body']: + """query bodies in the AABB region.""" + + def step(self, dt: float, velocity_iterations: int, position_iterations: int) -> None: + """step the simulation, e.g. world.step(1/60, 8, 3)""" + + # enum + # { + # e_shapeBit = 0x0001, ///< draw shapes + # e_jointBit = 0x0002, ///< draw joint connections + # e_aabbBit = 0x0004, ///< draw axis aligned bounding boxes + # e_pairBit = 0x0008, ///< draw broad-phase pairs + # e_centerOfMassBit = 0x0010 ///< draw center of mass frame + # }; + def debug_draw(self, flags: int): + """draw debug shapes of all bodies in the world.""" + + def set_debug_draw(self, draw: _DrawLike): + """set the debug draw object.""" + + def create_weld_joint(self, body_a: 'Body', body_b: 'Body'): + """create a weld joint between two bodies.""" + +class Body: + type: int # 0-static, 1-kinematic, 2-dynamic, by default 2 + gravity_scale: float + fixed_rotation: bool + enabled: bool + bullet: bool # whether to use continuous collision detection + + @property + def mass(self) -> float: ... + @property + def inertia(self) -> float: ... + + position: vec2 + rotation: float # in radians (counter-clockwise) + velocity: vec2 # linear velocity + angular_velocity: float + damping: float # linear damping + angular_damping: float + + # fixture settings + density: float + friction: float + restitution: float + restitution_threshold: float + is_sensor: bool + + def __new__(cls, world: World, node: _NodeLike = None): + """create a body in the world.""" + + def set_box_shape(self, hx: float, hy: float): ... + def set_circle_shape(self, radius: float): ... + def set_polygon_shape(self, points: list[vec2]): ... + def set_chain_shape(self, points: list[vec2]): ... + + def apply_force(self, force: vec2, point: vec2): ... + def apply_force_to_center(self, force: vec2): ... + def apply_torque(self, torque: float): ... + def apply_impulse(self, impulse: vec2, point: vec2): ... + def apply_impulse_to_center(self, impulse: vec2): ... + def apply_angular_impulse(self, impulse: float): ... + + def get_node(self) -> _NodeLike: + """return the node that is attached to this body.""" + + def get_contacts(self) -> list['Body']: + """return all bodies that are in contact with this body.""" + + def destroy(self): + """destroy this body.""" \ No newline at end of file diff --git a/include/c.pyi b/include/typings/c.pyi similarity index 100% rename from include/c.pyi rename to include/typings/c.pyi diff --git a/include/easing.pyi b/include/typings/easing.pyi similarity index 100% rename from include/easing.pyi rename to include/typings/easing.pyi diff --git a/include/linalg.pyi b/include/typings/linalg.pyi similarity index 95% rename from include/linalg.pyi rename to include/typings/linalg.pyi index e27a621c..36520777 100644 --- a/include/linalg.pyi +++ b/include/typings/linalg.pyi @@ -78,25 +78,21 @@ class mat3x3: def set_identity(self) -> None: ... def copy(self) -> mat3x3: ... + def determinant(self) -> float: ... + def transpose(self) -> mat3x3: ... + def __getitem__(self, index: tuple[int, int]) -> float: ... def __setitem__(self, index: tuple[int, int], value: float) -> None: ... def __add__(self, other: mat3x3) -> mat3x3: ... def __sub__(self, other: mat3x3) -> mat3x3: ... def __mul__(self, other: float) -> mat3x3: ... def __truediv__(self, other: float) -> mat3x3: ... + + def __invert__(self) -> mat3x3: ... @overload def __matmul__(self, other: mat3x3) -> mat3x3: ... @overload def __matmul__(self, other: vec3) -> vec3: ... - @overload - def matmul(self, other: mat3x3) -> mat3x3: ... - @overload - def matmul(self, other: vec3) -> vec3: ... - def determinant(self) -> float: ... - def transpose(self) -> mat3x3: ... - def inverse(self) -> mat3x3: ... - - def __invert__(self) -> mat3x3: ... @staticmethod def zeros() -> mat3x3: ... diff --git a/src/linalg.cpp b/src/linalg.cpp index 911ba07d..945e1c59 100644 --- a/src/linalg.cpp +++ b/src/linalg.cpp @@ -267,21 +267,20 @@ namespace pkpy{ return VAR(self.m[i][j]); }); - vm->bind_method<2>(type, "__setitem__", [](VM* vm, ArgsView args){ - PyMat3x3& self = _CAST(PyMat3x3&, args[0]); - Tuple& t = CAST(Tuple&, args[1]); + vm->bind__setitem__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj, PyObject* index, PyObject* value){ + PyMat3x3& self = _CAST(PyMat3x3&, obj); + Tuple& t = CAST(Tuple&, index); if(t.size() != 2){ vm->TypeError("Mat3x3.__setitem__ takes a tuple of 2 integers"); - return vm->None; + return; } i64 i = CAST(i64, t[0]); i64 j = CAST(i64, t[1]); if(i < 0 || i >= 3 || j < 0 || j >= 3){ vm->IndexError("index out of range"); - return vm->None; + return; } - self.m[i][j] = CAST_F(args[2]); - return vm->None; + self.m[i][j] = CAST_F(value); }); #define PROPERTY_FIELD(field) \ @@ -307,56 +306,53 @@ namespace pkpy{ #undef PROPERTY_FIELD - vm->bind_method<1>(type, "__add__", [](VM* vm, ArgsView args){ - PyMat3x3& self = _CAST(PyMat3x3&, args[0]); - PyMat3x3& other = CAST(PyMat3x3&, args[1]); + 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); }); - vm->bind_method<1>(type, "__sub__", [](VM* vm, ArgsView args){ - PyMat3x3& self = _CAST(PyMat3x3&, args[0]); - PyMat3x3& other = CAST(PyMat3x3&, args[1]); + 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); }); - vm->bind_method<1>(type, "__mul__", [](VM* vm, ArgsView args){ - PyMat3x3& self = _CAST(PyMat3x3&, args[0]); - f64 other = CAST_F(args[1]); + vm->bind__mul__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ + PyMat3x3& self = _CAST(PyMat3x3&, _0); + f64 other = CAST_F(_1); return VAR_T(PyMat3x3, self * other); }); + vm->bind_method<1>(type, "__rmul__", [](VM* vm, ArgsView args){ PyMat3x3& self = _CAST(PyMat3x3&, args[0]); f64 other = CAST_F(args[1]); return VAR_T(PyMat3x3, self * other); }); - vm->bind_method<1>(type, "__truediv__", [](VM* vm, ArgsView args){ - PyMat3x3& self = _CAST(PyMat3x3&, args[0]); - f64 other = CAST_F(args[1]); + vm->bind__truediv__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* _0, PyObject* _1){ + PyMat3x3& self = _CAST(PyMat3x3&, _0); + f64 other = CAST_F(_1); return VAR_T(PyMat3x3, self / other); }); - auto f_mm = [](VM* vm, ArgsView args){ - PyMat3x3& self = _CAST(PyMat3x3&, args[0]); - if(is_non_tagged_type(args[1], PyMat3x3::_type(vm))){ - PyMat3x3& other = _CAST(PyMat3x3&, args[1]); + 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))){ + PyMat3x3& other = _CAST(PyMat3x3&, _1); return VAR_T(PyMat3x3, self.matmul(other)); } - if(is_non_tagged_type(args[1], PyVec3::_type(vm))){ - PyVec3& other = _CAST(PyVec3&, args[1]); + if(is_non_tagged_type(_1, PyVec3::_type(vm))){ + PyVec3& other = _CAST(PyVec3&, _1); return VAR_T(PyVec3, self.matmul(other)); } - vm->BinaryOptError("@"); - return vm->None; - }; + return vm->NotImplemented; + }); - vm->bind_method<1>(type, "__matmul__", f_mm); - vm->bind_method<1>(type, "matmul", f_mm); - - vm->bind_method<1>(type, "__eq__", [](VM* vm, ArgsView args){ - PyMat3x3& self = _CAST(PyMat3x3&, args[0]); - if(is_non_tagged_type(args[1], PyMat3x3::_type(vm))){ - PyMat3x3& other = _CAST(PyMat3x3&, args[1]); + vm->bind__eq__(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))){ + PyMat3x3& other = _CAST(PyMat3x3&, _1); return VAR(self == other); } return vm->NotImplemented; @@ -372,14 +368,6 @@ namespace pkpy{ return VAR_T(PyMat3x3, self.transpose()); }); - vm->bind_method<0>(type, "inverse", [](VM* vm, ArgsView args){ - PyMat3x3& self = _CAST(PyMat3x3&, args[0]); - Mat3x3 ret; - bool ok = self.inverse(ret); - if(!ok) vm->ValueError("matrix is not invertible"); - return VAR_T(PyMat3x3, ret); - }); - vm->bind__invert__(PK_OBJ_GET(Type, type), [](VM* vm, PyObject* obj){ PyMat3x3& self = _CAST(PyMat3x3&, obj); Mat3x3 ret;