Skip to content

Commit dfbd376

Browse files
GeequlimGeequlim
committed
Finish mannually bind member of builtin types
1 parent dbb3c14 commit dfbd376

File tree

3 files changed

+208
-12
lines changed

3 files changed

+208
-12
lines changed

‎generate_builtin_api.py

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -223,7 +223,7 @@
223223
"Basis": ['is_equal_approx'],
224224
"Plane": ['intersects_segment', 'intersects_ray', 'intersect_3'],
225225
"AABB": ['end'],
226-
"Transform": ['xform', 'xform_inv', 'IDENTITY', 'FLIP_X', 'FLIP_Y', 'FLIP_Z'],
226+
"Transform": ['xform', 'xform_inv'],
227227
"PoolByteArray": ['compress', 'decompress', 'get_string_from_ascii', 'get_string_from_utf8', 'hex_encode'],
228228
}
229229

‎misc/godot.d.ts

Lines changed: 9 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -673,7 +673,7 @@ declare module godot {
673673
inverse() : Basis;
674674

675675
/** */
676-
// is_equal_approx(b: Basis, epsilon?: number) : boolean;
676+
is_equal_approx(b: Basis) : boolean;
677677

678678
/** Returns the orthonormalized version of the matrix (useful to call from time to time to avoid rounding error for orthogonal matrices). This performs a Gram-Schmidt orthonormalization on the basis of the matrix. */
679679
orthonormalized() : Basis;
@@ -772,11 +772,10 @@ declare module godot {
772772
translated(ofs: Vector3) : Transform;
773773

774774
/** Transforms the given `Vector3`, `Plane`, `AABB`, or `PoolVector3Array` by this transform. */
775-
// xform(v: any) : any;
775+
xform<T extends Vector3|Plane|AABB >(v: T) : T;
776776

777777
/** Inverse-transforms the given `Vector3`, `Plane`, `AABB`, or `PoolVector3Array` by this transform. */
778-
// xform_inv(v: any) : any;
779-
778+
xform_inv<T extends Vector3|Plane|AABB >(v: T) : T;
780779
}
781780

782781
namespace Transform {
@@ -856,10 +855,10 @@ declare module godot {
856855
translated(offset: Vector2) : Transform2D;
857856

858857
/** Transforms the given `Vector2`, `Rect2`, or `PoolVector2Array` by this transform. */
859-
// xform(v: any) : any;
858+
xform<T extends Vector2 | Rect2 >(v: T) : T;
860859

861860
/** Inverse-transforms the given `Vector2`, `Rect2`, or `PoolVector2Array` by this transform. */
862-
// xform_inv(v: any) : any;
861+
xform_inv<T extends Vector2 | Rect2 >(v: T) : T;
863862

864863
}
865864

@@ -1698,13 +1697,13 @@ declare module godot {
16981697
has_point(point: Vector3, epsilon?: number) : boolean;
16991698

17001699
/** Returns the intersection point of the three planes `b`, `c` and this plane. If no intersection is found, `null` is returned. */
1701-
// intersect_3(b: Plane, c: Plane) : Vector3;
1700+
intersect_3(b: Plane, c: Plane) : Vector3;
17021701

17031702
/** Returns the intersection point of a ray consisting of the position `from` and the direction normal `dir` with this plane. If no intersection is found, `null` is returned. */
1704-
// intersects_ray(p_from: Vector3, dir: Vector3) : Vector3;
1703+
intersects_ray(p_from: Vector3, dir: Vector3) : Vector3;
17051704

17061705
/** Returns the intersection point of a segment from position `begin` to position `end` with this plane. If no intersection is found, `null` is returned. */
1707-
// intersects_segment(begin: Vector3, end: Vector3) : Vector3;
1706+
intersects_segment(begin: Vector3, end: Vector3) : Vector3;
17081707

17091708
/** */
17101709
is_equal_approx(plane: Plane) : boolean;
@@ -1820,8 +1819,7 @@ declare module godot {
18201819
size: Vector3;
18211820

18221821
/** Ending corner. */
1823-
// end: Vector3;
1824-
1822+
end: Vector3;
18251823

18261824
/** Returns `true` if this `AABB` completely encloses another one. */
18271825
encloses(p_with: AABB) : boolean;

‎quickjs/quickjs_builtin_binder.cpp

Lines changed: 198 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -738,6 +738,204 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
738738
2);
739739
}
740740

741+
{ // Transform2D
742+
binder->get_builtin_binder().register_method(
743+
Variant::TRANSFORM2D,
744+
"xform",
745+
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
746+
ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform2D.xform")));
747+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
748+
Transform2D *ptr = bind->getTransform2D();
749+
if (QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[0])) {
750+
Vector2 ret = ptr->xform(Vector2(QuickJSBinder::var_to_variant(ctx, argv[0])));
751+
return QuickJSBinder::variant_to_var(ctx, ret);
752+
} else if (QuickJSBinder::validate_type(ctx, Variant::RECT2, argv[0])) {
753+
Rect2 ret = ptr->xform(Rect2(QuickJSBinder::var_to_variant(ctx, argv[0])));
754+
return QuickJSBinder::variant_to_var(ctx, ret);
755+
} else if (QuickJSBinder::validate_type(ctx, Variant::POOL_VECTOR2_ARRAY, argv[0])) {
756+
PoolVector2Array ret = ptr->xform(PoolVector2Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
757+
return QuickJSBinder::variant_to_var(ctx, ret);
758+
}
759+
ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector2, Rect2 or PoolVector2Array expected for argument #0 of Transform2D.xform"));
760+
},
761+
1);
762+
binder->get_builtin_binder().register_method(
763+
Variant::TRANSFORM2D,
764+
"xform_inv",
765+
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
766+
ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform2D.xform_inv")));
767+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
768+
Transform2D *ptr = bind->getTransform2D();
769+
if (QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[0])) {
770+
Vector2 ret = ptr->xform_inv(Vector2(QuickJSBinder::var_to_variant(ctx, argv[0])));
771+
return QuickJSBinder::variant_to_var(ctx, ret);
772+
} else if (QuickJSBinder::validate_type(ctx, Variant::RECT2, argv[0])) {
773+
Rect2 ret = ptr->xform_inv(Rect2(QuickJSBinder::var_to_variant(ctx, argv[0])));
774+
return QuickJSBinder::variant_to_var(ctx, ret);
775+
} else if (QuickJSBinder::validate_type(ctx, Variant::POOL_VECTOR2_ARRAY, argv[0])) {
776+
PoolVector2Array ret = ptr->xform_inv(PoolVector2Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
777+
return QuickJSBinder::variant_to_var(ctx, ret);
778+
}
779+
ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector2, Rect2 or PoolVector2Array expected for argument #0 of Transform2D.xform_inv"));
780+
},
781+
1);
782+
}
783+
784+
{ // Basis
785+
binder->get_builtin_binder().register_method(
786+
Variant::BASIS,
787+
"is_equal_approx",
788+
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
789+
ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Basis.is_equal_approx")));
790+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
791+
Basis *ptr = bind->getBasis();
792+
#ifdef DEBUG_METHODS_ENABLED
793+
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::BASIS, argv[0]), (JS_ThrowTypeError(ctx, "Basis expected for Basis.is_equal_approx")));
794+
#endif
795+
ECMAScriptGCHandler *argv_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
796+
bool ret = ptr->is_equal_approx(*argv_bind->getBasis());
797+
return QuickJSBinder::to_js_bool(ctx, ret);
798+
},
799+
1);
800+
}
801+
802+
{ // AABB
803+
JSCFunctionMagic *getter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
804+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
805+
const AABB *ptr = bind->getAABB();
806+
switch (magic) {
807+
case 0:
808+
return QuickJSBinder::variant_to_var(ctx, ptr->size + ptr->position);
809+
}
810+
return JS_UNDEFINED;
811+
};
812+
JSCFunctionMagic *setter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
813+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
814+
AABB *ptr = bind->getAABB();
815+
switch (magic) {
816+
case 0:
817+
#ifdef DEBUG_METHODS_ENABLED
818+
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for AABB.end")));
819+
#endif
820+
ptr->size = Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])) - ptr->position;
821+
break;
822+
}
823+
return JS_DupValue(ctx, argv[0]);
824+
};
825+
binder->get_builtin_binder().register_property(Variant::AABB, "end", getter, setter, 0);
826+
}
827+
828+
{ // Plane
829+
binder->get_builtin_binder().register_method(
830+
Variant::PLANE,
831+
"intersect_3",
832+
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
833+
ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Plane.intersect_3")));
834+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
835+
Plane *ptr = bind->getPlane();
836+
#ifdef DEBUG_METHODS_ENABLED
837+
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0]), (JS_ThrowTypeError(ctx, "Plane expected for arguments #0 Plane.intersect_3")));
838+
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[1]), (JS_ThrowTypeError(ctx, "Plane expected for arguments #1 Plane.intersect_3")));
839+
#endif
840+
Vector3 ret;
841+
ECMAScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
842+
ECMAScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
843+
if (ptr->intersect_3(*argv0_bind->getPlane(), *argv1_bind->getPlane(), &ret)) {
844+
return QuickJSBinder::variant_to_var(ctx, ret);
845+
}
846+
return JS_NULL;
847+
},
848+
2);
849+
binder->get_builtin_binder().register_method(
850+
Variant::PLANE,
851+
"intersects_ray",
852+
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
853+
ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Plane.intersects_ray")));
854+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
855+
Plane *ptr = bind->getPlane();
856+
#ifdef DEBUG_METHODS_ENABLED
857+
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for arguments #0 Plane.intersects_ray")));
858+
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for arguments #1 Plane.intersects_ray")));
859+
#endif
860+
Vector3 ret;
861+
ECMAScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
862+
ECMAScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
863+
if (ptr->intersects_ray(*argv0_bind->getVector3(), *argv1_bind->getVector3(), &ret)) {
864+
return QuickJSBinder::variant_to_var(ctx, ret);
865+
}
866+
return JS_NULL;
867+
},
868+
2);
869+
binder->get_builtin_binder().register_method(
870+
Variant::PLANE,
871+
"intersects_segment",
872+
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
873+
ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Plane.intersects_segment")));
874+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
875+
Plane *ptr = bind->getPlane();
876+
#ifdef DEBUG_METHODS_ENABLED
877+
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for arguments #0 Plane.intersects_segment")));
878+
ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for arguments #1 Plane.intersects_segment")));
879+
#endif
880+
Vector3 ret;
881+
ECMAScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
882+
ECMAScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
883+
if (ptr->intersects_segment(*argv0_bind->getVector3(), *argv1_bind->getVector3(), &ret)) {
884+
return QuickJSBinder::variant_to_var(ctx, ret);
885+
}
886+
return JS_NULL;
887+
},
888+
2);
889+
}
890+
{ // Transform
891+
binder->get_builtin_binder().register_method(
892+
Variant::TRANSFORM,
893+
"xform",
894+
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
895+
ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform.xform")));
896+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
897+
Transform *ptr = bind->getTransform();
898+
if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
899+
Vector3 ret = ptr->xform(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
900+
return QuickJSBinder::variant_to_var(ctx, ret);
901+
} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
902+
Plane ret = ptr->xform(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
903+
return QuickJSBinder::variant_to_var(ctx, ret);
904+
} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
905+
AABB ret = ptr->xform(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
906+
return QuickJSBinder::variant_to_var(ctx, ret);
907+
} else if (QuickJSBinder::validate_type(ctx, Variant::POOL_VECTOR3_ARRAY, argv[0])) {
908+
PoolVector3Array ret = ptr->xform(PoolVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
909+
return QuickJSBinder::variant_to_var(ctx, ret);
910+
}
911+
ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PoolVector3Array expected for argument #0 of Transform.xform"));
912+
},
913+
1);
914+
binder->get_builtin_binder().register_method(
915+
Variant::TRANSFORM,
916+
"xform_inv",
917+
[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
918+
ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform.xform_inv")));
919+
ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
920+
Transform *ptr = bind->getTransform();
921+
if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
922+
Vector3 ret = ptr->xform_inv(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
923+
return QuickJSBinder::variant_to_var(ctx, ret);
924+
} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
925+
Plane ret = ptr->xform_inv(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
926+
return QuickJSBinder::variant_to_var(ctx, ret);
927+
} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
928+
AABB ret = ptr->xform_inv(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
929+
return QuickJSBinder::variant_to_var(ctx, ret);
930+
} else if (QuickJSBinder::validate_type(ctx, Variant::POOL_VECTOR3_ARRAY, argv[0])) {
931+
PoolVector3Array ret = ptr->xform_inv(PoolVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
932+
return QuickJSBinder::variant_to_var(ctx, ret);
933+
}
934+
ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PoolVector3Array expected for argument #0 of Transform.xform_inv"));
935+
},
936+
1);
937+
}
938+
741939
{ // PoolByteArray
742940
// PoolByteArray.prototype.compress
743941
binder->get_builtin_binder().register_method(

0 commit comments

Comments
 (0)