PhysicsServer2D

public static void AreaAddShape(Rid area, Rid shape, Transform2D? transform = default, bool disabled = false);

Adds a shape to the area, with the given local transform. The shape (together with its transform and disabled properties) is added to an array of shapes, and the shapes of an area are usually referenced by their index in this array.

public static void AreaAttachCanvasInstanceId(Rid area, ulong id);

Attaches the ObjectID of a canvas to the area. Use ReckfellObject.GetInstanceId to get the ObjectID of a CanvasLayer.

public static void AreaAttachObjectInstanceId(Rid area, ulong id);

Attaches the ObjectID of an ReckfellObject to the area. Use ReckfellObject.GetInstanceId to get the ObjectID of a CollisionObject2D.

public static void AreaClearShapes(Rid area);

Removes all shapes from the area. This does not delete the shapes themselves, so they can continue to be used elsewhere or added back later.

public static Rid AreaCreate();

Creates a 2D area object in the physics server, and returns the Rid that identifies it. The default settings for the created area include a collision layer and mask set to 1, and monitorable set to false. Use PhysicsServer2D.AreaAddShape to add shapes to it, use PhysicsServer2D.AreaSetTransform to set its transform, and use PhysicsServer2D.AreaSetSpace to add the area to a space. If you want the area to be detectable use PhysicsServer2D.AreaSetMonitorable.

public static ulong AreaGetCanvasInstanceId(Rid area);

Returns the ObjectID of the canvas attached to the area. Use @GlobalScope.instance_from_id to retrieve a CanvasLayer from a nonzero ObjectID.

public static uint AreaGetCollisionLayer(Rid area);

Returns the physics layer or layers the area belongs to, as a bitmask.

public static uint AreaGetCollisionMask(Rid area);

Returns the physics layer or layers the area can contact with, as a bitmask.

public static ulong AreaGetObjectInstanceId(Rid area);

Returns the ObjectID attached to the area. Use @GlobalScope.instance_from_id to retrieve an ReckfellObject from a nonzero ObjectID.

public static Variant AreaGetParam(Rid area, PhysicsServer2D.AreaParameter param);

Returns the value of the given area parameter.

public static Rid AreaGetShape(Rid area, int shapeIdx);

Returns the Rid of the shape with the given index in the area's array of shapes.

public static int AreaGetShapeCount(Rid area);

Returns the number of shapes added to the area.

public static Transform2D AreaGetShapeTransform(Rid area, int shapeIdx);

Returns the local transform matrix of the shape with the given index in the area's array of shapes.

public static Rid AreaGetSpace(Rid area);

Returns the Rid of the space assigned to the area. Returns an empty Rid if no space is assigned.

public static Transform2D AreaGetTransform(Rid area);

Returns the transform matrix of the area.

public static void AreaRemoveShape(Rid area, int shapeIdx);

Removes the shape with the given index from the area's array of shapes. The shape itself is not deleted, so it can continue to be used elsewhere or added back later. As a result of this operation, the area's shapes which used to have indices higher than shape_idx will have their index decreased by one.

public static void AreaSetAreaMonitorCallback(Rid area, Callable callback);

Sets the area's area monitor callback. This callback will be called when any other (shape of an) area enters or exits (a shape of) the given area, and must take the following five parameters:

1. an integer status: either PhysicsServer2D.AreaBodyStatus.Added or PhysicsServer2D.AreaBodyStatus.Removed depending on whether the other area's shape entered or exited the area,
2. an Rid area_rid: the Rid of the other area that entered or exited the area,
3. an integer instance_id: the ObjectID attached to the other area,
4. an integer area_shape_idx: the index of the shape of the other area that entered or exited the area,
5. an integer self_shape_idx: the index of the shape of the area where the other area entered or exited. By counting (or keeping track of) the shapes that enter and exit, it can be determined if an area (with all its shapes) is entering for the first time or exiting for the last time.

public static void AreaSetCollisionLayer(Rid area, uint layer);

Assigns the area to one or many physics layers, via a bitmask.

public static void AreaSetCollisionMask(Rid area, uint mask);

Sets which physics layers the area will monitor, via a bitmask.

public static void AreaSetMonitorCallback(Rid area, Callable callback);

Sets the area's body monitor callback. This callback will be called when any other (shape of a) body enters or exits (a shape of) the given area, and must take the following five parameters:

1. an integer status: either PhysicsServer2D.AreaBodyStatus.Added or PhysicsServer2D.AreaBodyStatus.Removed depending on whether the other body shape entered or exited the area,
2. an Rid body_rid: the Rid of the body that entered or exited the area,
3. an integer instance_id: the ObjectID attached to the body,
4. an integer body_shape_idx: the index of the shape of the body that entered or exited the area,
5. an integer self_shape_idx: the index of the shape of the area where the body entered or exited. By counting (or keeping track of) the shapes that enter and exit, it can be determined if a body (with all its shapes) is entering for the first time or exiting for the last time.

public static void AreaSetMonitorable(Rid area, bool monitorable);

Sets whether the area is monitorable or not. If monitorable is true, the area monitoring callback of other areas will be called when this area enters or exits them.

public static void AreaSetParam(Rid area, PhysicsServer2D.AreaParameter param, Variant value);

Sets the value of the given area parameter.

public static void AreaSetShape(Rid area, int shapeIdx, Rid shape);

Replaces the area's shape at the given index by another shape, while not affecting the transform and disabled properties at the same index.

public static void AreaSetShapeDisabled(Rid area, int shapeIdx, bool disabled);

Sets the disabled property of the area's shape with the given index. If disabled is true, then the shape will not detect any other shapes entering or exiting it.

public static void AreaSetShapeTransform(Rid area, int shapeIdx, Transform2D transform);

Sets the local transform matrix of the area's shape with the given index.

public static void AreaSetSpace(Rid area, Rid space);

Adds the area to the given space, after removing the area from the previously assigned space (if any). Note: To remove an area from a space without immediately adding it back elsewhere, use PhysicsServer2D.area_set_space(area, RID()).

public static void AreaSetTransform(Rid area, Transform2D transform);

Sets the transform matrix of the area.

public static void BodyAddCollisionException(Rid body, Rid exceptedBody);

Adds excepted_body to the body's list of collision exceptions, so that collisions with it are ignored.

public static void BodyAddConstantCentralForce(Rid body, Vector2 force);

Adds a constant directional force to the body. The force does not affect rotation. The force remains applied over time until cleared with PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0)). This is equivalent to using PhysicsServer2D.BodyAddConstantForce at the body's center of mass.

public static void BodyAddConstantForce(Rid body, Vector2 force, Vector2? position = default);

Adds a constant positioned force to the body. The force can affect rotation if position is different from the body's center of mass. The force remains applied over time until cleared with PhysicsServer2D.body_set_constant_force(body, Vector2(0, 0)). position is the offset from the body origin in global coordinates.

public static void BodyAddConstantTorque(Rid body, float torque);

Adds a constant rotational force to the body. The force does not affect position. The force remains applied over time until cleared with PhysicsServer2D.body_set_constant_torque(body, 0).

public static void BodyAddShape(Rid body, Rid shape, Transform2D? transform = default, bool disabled = false);

Adds a shape to the area, with the given local transform. The shape (together with its transform and disabled properties) is added to an array of shapes, and the shapes of a body are usually referenced by their index in this array.

public static void BodyApplyCentralForce(Rid body, Vector2 force);

Applies a directional force to the body, at the body's center of mass. The force does not affect rotation. A force is time dependent and meant to be applied every physics update. This is equivalent to using PhysicsServer2D.BodyApplyForce at the body's center of mass.

public static void BodyApplyCentralImpulse(Rid body, Vector2 impulse);

Applies a directional impulse to the body, at the body's center of mass. The impulse does not affect rotation. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise). This is equivalent to using PhysicsServer2D.BodyApplyImpulse at the body's center of mass.

public static void BodyApplyForce(Rid body, Vector2 force, Vector2? position = default);

Applies a positioned force to the body. The force can affect rotation if position is different from the body's center of mass. A force is time dependent and meant to be applied every physics update. position is the offset from the body origin in global coordinates.

public static void BodyApplyImpulse(Rid body, Vector2 impulse, Vector2? position = default);

Applies a positioned impulse to the body. The impulse can affect rotation if position is different from the body's center of mass. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise). position is the offset from the body origin in global coordinates.

public static void BodyApplyTorque(Rid body, float torque);

Applies a rotational force to the body. The force does not affect position. A force is time dependent and meant to be applied every physics update.

public static void BodyApplyTorqueImpulse(Rid body, float impulse);

Applies a rotational impulse to the body. The impulse does not affect position. An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).

public static void BodyAttachCanvasInstanceId(Rid body, ulong id);

Attaches the ObjectID of a canvas to the body. Use ReckfellObject.GetInstanceId to get the ObjectID of a CanvasLayer.

public static void BodyAttachObjectInstanceId(Rid body, ulong id);

Attaches the ObjectID of an ReckfellObject to the body. Use ReckfellObject.GetInstanceId to get the ObjectID of a CollisionObject2D.

public static void BodyClearShapes(Rid body);

Removes all shapes from the body. This does not delete the shapes themselves, so they can continue to be used elsewhere or added back later.

public static Rid BodyCreate();

Creates a 2D body object in the physics server, and returns the Rid that identifies it. The default settings for the created area include a collision layer and mask set to 1, and body mode set to PhysicsServer2D.BodyMode.Rigid. Use PhysicsServer2D.BodyAddShape to add shapes to it, use PhysicsServer2D.BodySetState to set its transform, and use PhysicsServer2D.BodySetSpace to add the body to a space.

public static ulong BodyGetCanvasInstanceId(Rid body);

Returns the ObjectID of the canvas attached to the body. Use @GlobalScope.instance_from_id to retrieve a CanvasLayer from a nonzero ObjectID.

public static uint BodyGetCollisionLayer(Rid body);

Returns the physics layer or layers the body belongs to, as a bitmask.

public static uint BodyGetCollisionMask(Rid body);

Returns the physics layer or layers the body can collide with, as a bitmask.

public static float BodyGetCollisionPriority(Rid body);

Returns the body's collision priority. This is used in the depenetration phase of PhysicsServer2D.BodyTestMotion. The higher the priority is, the lower the penetration into the body will be.

public static Vector2 BodyGetConstantForce(Rid body);

Returns the body's total constant positional force applied during each physics update. See PhysicsServer2D.BodyAddConstantForce and PhysicsServer2D.BodyAddConstantCentralForce.

public static float BodyGetConstantTorque(Rid body);

Returns the body's total constant rotational force applied during each physics update. See PhysicsServer2D.BodyAddConstantTorque.

public static PhysicsServer2D.CcdMode BodyGetContinuousCollisionDetectionMode(Rid body);

Returns the body's continuous collision detection mode.

public static PhysicsDirectBodyState2D BodyGetDirectState(Rid body);

Returns the PhysicsDirectBodyState2D of the body. Returns null if the body is destroyed or not assigned to a space.

public static int BodyGetMaxContactsReported(Rid body);

Returns the maximum number of contacts that the body can report. See PhysicsServer2D.BodySetMaxContactsReported.

public static PhysicsServer2D.BodyMode BodyGetMode(Rid body);

Returns the body's mode.

public static ulong BodyGetObjectInstanceId(Rid body);

Returns the ObjectID attached to the body. Use @GlobalScope.instance_from_id to retrieve an ReckfellObject from a nonzero ObjectID.

public static Variant BodyGetParam(Rid body, PhysicsServer2D.BodyParameter param);

Returns the value of the given body parameter.

public static Rid BodyGetShape(Rid body, int shapeIdx);

Returns the Rid of the shape with the given index in the body's array of shapes.

public static int BodyGetShapeCount(Rid body);

Returns the number of shapes added to the body.

public static Transform2D BodyGetShapeTransform(Rid body, int shapeIdx);

Returns the local transform matrix of the shape with the given index in the area's array of shapes.

public static Rid BodyGetSpace(Rid body);

Returns the Rid of the space assigned to the body. Returns an empty Rid if no space is assigned.

public static Variant BodyGetState(Rid body, PhysicsServer2D.BodyState state);

Returns the value of the given state of the body.

public static bool BodyIsOmittingForceIntegration(Rid body);

Returns true if the body is omitting the standard force integration. See PhysicsServer2D.BodySetOmitForceIntegration.

public static void BodyRemoveCollisionException(Rid body, Rid exceptedBody);

Removes excepted_body from the body's list of collision exceptions, so that collisions with it are no longer ignored.

public static void BodyRemoveShape(Rid body, int shapeIdx);

Removes the shape with the given index from the body's array of shapes. The shape itself is not deleted, so it can continue to be used elsewhere or added back later. As a result of this operation, the body's shapes which used to have indices higher than shape_idx will have their index decreased by one.

public static void BodyResetMassProperties(Rid body);

Restores the default inertia and center of mass of the body based on its shapes. This undoes any custom values previously set using PhysicsServer2D.BodySetParam.

public static void BodySetAxisVelocity(Rid body, Vector2 axisVelocity);

Modifies the body's linear velocity so that its projection to the axis axis_velocity.normalized() is exactly axis_velocity.length(). This is useful for jumping behavior.

public static void BodySetCollisionLayer(Rid body, uint layer);

Sets the physics layer or layers the body belongs to, via a bitmask.

public static void BodySetCollisionMask(Rid body, uint mask);

Sets the physics layer or layers the body can collide with, via a bitmask.

public static void BodySetCollisionPriority(Rid body, float priority);

Sets the body's collision priority. This is used in the depenetration phase of PhysicsServer2D.BodyTestMotion. The higher the priority is, the lower the penetration into the body will be.

public static void BodySetConstantForce(Rid body, Vector2 force);

Sets the body's total constant positional force applied during each physics update. See PhysicsServer2D.BodyAddConstantForce and PhysicsServer2D.BodyAddConstantCentralForce.

public static void BodySetConstantTorque(Rid body, float torque);

Sets the body's total constant rotational force applied during each physics update. See PhysicsServer2D.BodyAddConstantTorque.

public static void BodySetContinuousCollisionDetectionMode(Rid body, PhysicsServer2D.CcdMode mode);

Sets the continuous collision detection mode. Continuous collision detection tries to predict where a moving body would collide in between physics updates, instead of moving it and correcting its movement if it collided.

public static void BodySetForceIntegrationCallback(Rid body, Callable callable, Variant userdata = default);

Sets the body's custom force integration callback function to callable. Use an empty Callable ([code skip-lint]Callable()) to clear the custom callback. The function callable will be called every physics tick, before the standard force integration (see [PhysicsServer2D.BodySetOmitForceIntegration](/en/docs/api/physicsserver2d#member-bodysetomitforceintegration-9db2f3f9a1)). It can be used for example to update the body's linear and angular velocity based on contact with other bodies. If userdatais notnull, the function callable` must take the following two parameters:

1. state: a PhysicsDirectBodyState2D used to retrieve and modify the body's state,
2. Variant; its value will be the userdata passed into this method. If userdata is null, then callable must take only the state parameter.

public static void BodySetMaxContactsReported(Rid body, int amount);

Sets the maximum number of contacts that the body can report. If amount is greater than zero, then the body will keep track of at most this many contacts with other bodies.

public static void BodySetMode(Rid body, PhysicsServer2D.BodyMode mode);

Sets the body's mode.

public static void BodySetOmitForceIntegration(Rid body, bool enable);

Sets whether the body omits the standard force integration. If enable is true, the body will not automatically use applied forces, torques, and damping to update the body's linear and angular velocity. In this case, PhysicsServer2D.BodySetForceIntegrationCallback can be used to manually update the linear and angular velocity instead. This method is called when the property RigidBody2D.CustomIntegrator is set.

public static void BodySetParam(Rid body, PhysicsServer2D.BodyParameter param, Variant value);

Sets the value of the given body parameter.

public static void BodySetShape(Rid body, int shapeIdx, Rid shape);

Replaces the body's shape at the given index by another shape, while not affecting the transform, disabled, and one-way collision properties at the same index.

public static void BodySetShapeAsOneWayCollision(Rid body, int shapeIdx, bool enable, float margin);

Sets the one-way collision properties of the body's shape with the given index. If enable is true, the one-way collision direction given by direction in the shape's local space (that is body_get_shape_transform(body, shape_idx).basis_xform(direction).normalized() in the body's local space) will be used to ignore collisions with the shape in the opposite direction, and to ensure depenetration of kinematic bodies happens in this direction.

public static void BodySetShapeAsOneWayCollision(Rid body, int shapeIdx, bool enable, float margin, Vector2? direction = default);

Sets the one-way collision properties of the body's shape with the given index. If enable is true, the one-way collision direction given by direction in the shape's local space (that is body_get_shape_transform(body, shape_idx).basis_xform(direction).normalized() in the body's local space) will be used to ignore collisions with the shape in the opposite direction, and to ensure depenetration of kinematic bodies happens in this direction.

public static void BodySetShapeDisabled(Rid body, int shapeIdx, bool disabled);

Sets the disabled property of the body's shape with the given index. If disabled is true, then the shape will be ignored in all collision detection.

public static void BodySetShapeTransform(Rid body, int shapeIdx, Transform2D transform);

Sets the local transform matrix of the body's shape with the given index.

public static void BodySetSpace(Rid body, Rid space);

Adds the body to the given space, after removing the body from the previously assigned space (if any). If the body's mode is set to PhysicsServer2D.BodyMode.Rigid, then adding the body to a space will have the following additional effects:

• If the parameter PhysicsServer2D.BodyParameter.CenterOfMass has never been set explicitly, then the value of that parameter will be recalculated based on the body's shapes.
• If the parameter PhysicsServer2D.BodyParameter.Inertia is set to a value <= 0.0, then the value of that parameter will be recalculated based on the body's shapes, mass, and center of mass. Note: To remove a body from a space without immediately adding it back elsewhere, use PhysicsServer2D.body_set_space(body, RID()).

public static void BodySetState(Rid body, PhysicsServer2D.BodyState state, Variant value);

Sets the value of a body's state. Note: The state change doesn't take effect immediately. The state will change on the next physics frame.

public static void BodySetStateSyncCallback(Rid body, Callable callable);

Sets the body's state synchronization callback function to callable. Use an empty Callable ([code skip-lint]Callable()) to clear the callback. The function callablewill be called every physics frame, assuming that the body was active during the previous physics tick, and can be used to fetch the latest state from the physics server. The functioncallable` must take the following parameters:

1. state: a PhysicsDirectBodyState2D, used to retrieve the body's state.

public static bool BodyTestMotion(Rid body, PhysicsTestMotionParameters2D parameters, PhysicsTestMotionResult2D result = null);

Returns true if a collision would result from moving the body along a motion vector from a given point in space. See PhysicsTestMotionParameters2D for the available motion parameters. Optionally a PhysicsTestMotionResult2D object can be passed, which will be used to store the information about the resulting collision.

public static Rid CapsuleShapeCreate();

Creates a 2D capsule shape in the physics server, and returns the Rid that identifies it. Use PhysicsServer2D.ShapeSetData to set the capsule's height and radius.

public static Rid CircleShapeCreate();

Creates a 2D circle shape in the physics server, and returns the Rid that identifies it. Use PhysicsServer2D.ShapeSetData to set the circle's radius.

public static Rid ConcavePolygonShapeCreate();

Creates a 2D concave polygon shape in the physics server, and returns the Rid that identifies it. Use PhysicsServer2D.ShapeSetData to set the concave polygon's segments.

public static Rid ConvexPolygonShapeCreate();

Creates a 2D convex polygon shape in the physics server, and returns the Rid that identifies it. Use PhysicsServer2D.ShapeSetData to set the convex polygon's points.

public static float DampedSpringJointGetParam(Rid joint, PhysicsServer2D.DampedSpringParam param);

Returns the value of the given damped spring joint parameter.

public static void DampedSpringJointSetParam(Rid joint, PhysicsServer2D.DampedSpringParam param, float value);

Sets the value of the given damped spring joint parameter.

public static void FreeRid(Rid rid);

Destroys any of the objects created by PhysicsServer2D. If the Rid passed is not one of the objects that can be created by PhysicsServer2D, an error will be printed to the console.

public static int GetProcessInfo(PhysicsServer2D.ProcessInfo processInfo);

Returns the value of a physics engine state specified by process_info.

public static void JointClear(Rid joint);

Destroys the joint with the given Rid, creates a new uninitialized joint, and makes the Rid refer to this new joint.

public static Rid JointCreate();

Creates a 2D joint in the physics server, and returns the Rid that identifies it. To set the joint type, use PhysicsServer2D.JointMakeDampedSpring, PhysicsServer2D.JointMakeGroove or PhysicsServer2D.JointMakePin. Use PhysicsServer2D.JointSetParam to set generic joint parameters.

public static void JointDisableCollisionsBetweenBodies(Rid joint, bool disable);

Sets whether the bodies attached to the Joint2D will collide with each other.

public static float JointGetParam(Rid joint, PhysicsServer2D.JointParam param);

Returns the value of the given joint parameter.

public static PhysicsServer2D.JointType JointGetType(Rid joint);

Returns the joint's type.

public static bool JointIsDisabledCollisionsBetweenBodies(Rid joint);

Returns whether the bodies attached to the Joint2D will collide with each other.

public static void JointMakeDampedSpring(Rid joint, Vector2 anchorA, Vector2 anchorB, Rid bodyA, Rid bodyB = default);

Makes the joint a damped spring joint, attached at the point anchor_a (given in global coordinates) on the body body_a and at the point anchor_b (given in global coordinates) on the body body_b. To set the parameters which are specific to the damped spring, see PhysicsServer2D.DampedSpringJointSetParam.

public static void JointMakeGroove(Rid joint, Vector2 groove1A, Vector2 groove2A, Vector2 anchorB, Rid bodyA = default, Rid bodyB = default);

Makes the joint a groove joint.

public static void JointMakePin(Rid joint, Vector2 anchor, Rid bodyA, Rid bodyB = default);

Makes the joint a pin joint. If body_b is an empty Rid, then body_a is pinned to the point anchor (given in global coordinates); otherwise, body_a is pinned to body_b at the point anchor (given in global coordinates). To set the parameters which are specific to the pin joint, see PhysicsServer2D.PinJointSetParam.

public static void JointSetParam(Rid joint, PhysicsServer2D.JointParam param, float value);

Sets the value of the given joint parameter.

public static bool PinJointGetFlag(Rid joint, PhysicsServer2D.PinJointFlag flag);

Gets a pin joint flag.

public static float PinJointGetParam(Rid joint, PhysicsServer2D.PinJointParam param);

Returns the value of a pin joint parameter.

public static void PinJointSetFlag(Rid joint, PhysicsServer2D.PinJointFlag flag, bool enabled);

Sets a pin joint flag.

public static void PinJointSetParam(Rid joint, PhysicsServer2D.PinJointParam param, float value);

Sets a pin joint parameter.

public static Rid RectangleShapeCreate();

Creates a 2D rectangle shape in the physics server, and returns the Rid that identifies it. Use PhysicsServer2D.ShapeSetData to set the rectangle's half-extents.

public static Rid SegmentShapeCreate();

Creates a 2D segment shape in the physics server, and returns the Rid that identifies it. Use PhysicsServer2D.ShapeSetData to set the segment's start and end points.

public static Rid SeparationRayShapeCreate();

Creates a 2D separation ray shape in the physics server, and returns the Rid that identifies it. Use PhysicsServer2D.ShapeSetData to set the shape's length and slide_on_slope properties.

public static void SetActive(bool active);

Activates or deactivates the 2D physics server. If active is false, then the physics server will not do anything in its physics step.

public static Variant ShapeGetData(Rid shape);

Returns the shape data that defines the configuration of the shape, such as the half-extents of a rectangle or the segments of a concave shape. See PhysicsServer2D.ShapeSetData for the precise format of this data in each case.

public static PhysicsServer2D.ShapeType ShapeGetType(Rid shape);

Returns the shape's type.

public static void ShapeSetData(Rid shape, Variant data);

Sets the shape data that defines the configuration of the shape. The data to be passed depends on the shape's type (see PhysicsServer2D.ShapeGetType):

• PhysicsServer2D.ShapeType.WorldBoundary: an array of length two containing a Vector2 normal direction and a [float] distance d,
• PhysicsServer2D.ShapeType.SeparationRay: a dictionary containing the key length with a [float] value and the key slide_on_slope with a [bool] value,
• PhysicsServer2D.ShapeType.Segment: a Rect2 rect containing the first point of the segment in rect.position and the second point of the segment in rect.size,
• PhysicsServer2D.ShapeType.Circle: a [float] radius,
• PhysicsServer2D.ShapeType.Rectangle: a Vector2 half_extents,
• PhysicsServer2D.ShapeType.Capsule: an array of length two (or a Vector2) containing a [float] height and a [float] radius,
• PhysicsServer2D.ShapeType.ConvexPolygon: either a Vector2[] of points defining a convex polygon in counterclockwise order (the clockwise outward normal of each segment formed by consecutive points is calculated internally), or a float[] of length divisible by four so that every 4-tuple of [float]s contains the coordinates of a point followed by the coordinates of the clockwise outward normal vector to the segment between the current point and the next point,
• PhysicsServer2D.ShapeType.ConcavePolygon: a Vector2[] of length divisible by two (each pair of points forms one segment). Warning: In the case of PhysicsServer2D.ShapeType.ConvexPolygon, this method does not check if the points supplied actually form a convex polygon (unlike the CollisionPolygon2D.Polygon property).

public static Rid SpaceCreate();

Creates a 2D space in the physics server, and returns the Rid that identifies it. A space contains bodies and areas, and controls the stepping of the physics simulation of the objects in it.

public static PhysicsDirectSpaceState2D SpaceGetDirectState(Rid space);

Returns the state of a space, a PhysicsDirectSpaceState2D. This object can be used for collision/intersection queries.

public static float SpaceGetParam(Rid space, PhysicsServer2D.SpaceParameter param);

Returns the value of the given space parameter.

public static bool SpaceIsActive(Rid space);

Returns true if the space is active.

public static void SpaceSetActive(Rid space, bool active);

Activates or deactivates the space. If active is false, then the physics server will not do anything with this space in its physics step.

public static void SpaceSetParam(Rid space, PhysicsServer2D.SpaceParameter param, float value);

Sets the value of the given space parameter.

public static Rid WorldBoundaryShapeCreate();

Creates a 2D world boundary shape in the physics server, and returns the Rid that identifies it. Use PhysicsServer2D.ShapeSetData to set the shape's normal direction and distance properties.