asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/modules/bullet/bullet_physics_server.h

412 lines
20 KiB
C++
Raw Normal View History

Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/*************************************************************************/
/* bullet_physics_server.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
/* https://godotengine.org */
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/*************************************************************************/
Update copyright statements to 2021 Happy new year to the wonderful Godot community! 2020 has been a tough year for most of us personally, but a good year for Godot development nonetheless with a huge amount of work done towards Godot 4.0 and great improvements backported to the long-lived 3.2 branch. We've had close to 400 contributors to engine code this year, authoring near 7,000 commit! (And that's only for the `master` branch and for the engine code, there's a lot more when counting docs, demos and other first-party repos.) Here's to a great year 2021 for all Godot users 🎆
2021-01-01 20:13:46 +01:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#ifndef BULLET_PHYSICS_SERVER_H
#define BULLET_PHYSICS_SERVER_H
#include "area_bullet.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/templates/rid.h"
#include "core/templates/rid_owner.h"
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
#include "joint_bullet.h"
#include "rigid_body_bullet.h"
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
#include "servers/physics_server_3d.h"
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
#include "shape_bullet.h"
#include "soft_body_bullet.h"
#include "space_bullet.h"
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 17:01:17 +02:00
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
/**
@author AndreaCatania
*/
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
class BulletPhysicsServer3D : public PhysicsServer3D {
GDCLASS(BulletPhysicsServer3D, PhysicsServer3D);
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
friend class BulletPhysicsDirectSpaceState;
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 17:01:17 +02:00
bool active = true;
char active_spaces_count = 0;
Revert "- Enhanced the flush mechanism by flushing only needed thing." This reverts commit 8d0d6d6921d5dfb398f4ab04e4d3937ab550c4ff.
2020-10-08 12:16:12 +02:00
Vector<SpaceBullet *> active_spaces;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Refactored RID/RID_Owner to always use O(1) allocation. * Implements a growing chunked allocator * Removed redudant methods get and getptr, only getornull is supported now.
2019-06-10 17:38:51 +02:00
mutable RID_PtrOwner<SpaceBullet> space_owner;
mutable RID_PtrOwner<ShapeBullet> shape_owner;
mutable RID_PtrOwner<AreaBullet> area_owner;
mutable RID_PtrOwner<RigidBodyBullet> rigid_body_owner;
mutable RID_PtrOwner<SoftBodyBullet> soft_body_owner;
mutable RID_PtrOwner<JointBullet> joint_owner;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
protected:
static void _bind_methods();
public:
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
BulletPhysicsServer3D();
~BulletPhysicsServer3D();
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Refactored RID/RID_Owner to always use O(1) allocation. * Implements a growing chunked allocator * Removed redudant methods get and getptr, only getornull is supported now.
2019-06-10 17:38:51 +02:00
_FORCE_INLINE_ RID_PtrOwner<SpaceBullet> *get_space_owner() {
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
return &space_owner;
}
Refactored RID/RID_Owner to always use O(1) allocation. * Implements a growing chunked allocator * Removed redudant methods get and getptr, only getornull is supported now.
2019-06-10 17:38:51 +02:00
_FORCE_INLINE_ RID_PtrOwner<ShapeBullet> *get_shape_owner() {
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
return &shape_owner;
}
Refactored RID/RID_Owner to always use O(1) allocation. * Implements a growing chunked allocator * Removed redudant methods get and getptr, only getornull is supported now.
2019-06-10 17:38:51 +02:00
_FORCE_INLINE_ RID_PtrOwner<AreaBullet> *get_area_owner() {
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
return &area_owner;
}
Refactored RID/RID_Owner to always use O(1) allocation. * Implements a growing chunked allocator * Removed redudant methods get and getptr, only getornull is supported now.
2019-06-10 17:38:51 +02:00
_FORCE_INLINE_ RID_PtrOwner<RigidBodyBullet> *get_rigid_body_owner() {
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
return &rigid_body_owner;
}
Refactored RID/RID_Owner to always use O(1) allocation. * Implements a growing chunked allocator * Removed redudant methods get and getptr, only getornull is supported now.
2019-06-10 17:38:51 +02:00
_FORCE_INLINE_ RID_PtrOwner<SoftBodyBullet> *get_soft_body_owner() {
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
return &soft_body_owner;
}
Refactored RID/RID_Owner to always use O(1) allocation. * Implements a growing chunked allocator * Removed redudant methods get and getptr, only getornull is supported now.
2019-06-10 17:38:51 +02:00
_FORCE_INLINE_ RID_PtrOwner<JointBullet> *get_joint_owner() {
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
return &joint_owner;
}
/* SHAPE API */
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID shape_create(ShapeType p_shape) override;
virtual void shape_set_data(RID p_shape, const Variant &p_data) override;
virtual ShapeType shape_get_type(RID p_shape) const override;
virtual Variant shape_get_data(RID p_shape) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void shape_set_margin(RID p_shape, real_t p_margin) override;
virtual real_t shape_get_margin(RID p_shape) const override;
Expose bullet shape margin to UI. The margin value is exposed into the UI for shape ressource. This value can be modified through set_margin and get from get_margin or by using the property margin. Each time the margin is modified the associated collision shape is recreated and the margin value is used in ShapeBullet::prepare.
2018-07-10 14:50:14 +02:00
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// Not supported
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void shape_set_custom_solver_bias(RID p_shape, real_t p_bias) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// Not supported
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual real_t shape_get_custom_solver_bias(RID p_shape) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/* SPACE API */
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID space_create() override;
virtual void space_set_active(RID p_space, bool p_active) override;
virtual bool space_is_active(RID p_space) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// Not supported
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// Not supported
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual real_t space_get_param(RID p_space, SpaceParameter p_param) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual PhysicsDirectSpaceState3D *space_get_direct_state(RID p_space) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void space_set_debug_contacts(RID p_space, int p_max_contacts) override;
virtual Vector<Vector3> space_get_contacts(RID p_space) const override;
virtual int space_get_contact_count(RID p_space) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/* AREA API */
/// Bullet Physics Engine not support "Area", this must be handled by the game developer in another way.
/// Since godot Physics use the concept of area even to define the main world, the API area_set_param is used to set initial physics world information.
/// The API area_set_param is a bit hacky, and allow Godot to set some parameters on Bullet's world, a different use print a warning to console.
/// All other APIs returns a warning message if used
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID area_create() override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void area_set_space(RID p_area, RID p_space) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID area_get_space(RID p_area) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void area_set_space_override_mode(RID p_area, AreaSpaceOverrideMode p_mode) override;
virtual AreaSpaceOverrideMode area_get_space_override_mode(RID p_area) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void area_add_shape(RID p_area, RID p_shape, const Transform &p_transform = Transform(), bool p_disabled = false) override;
virtual void area_set_shape(RID p_area, int p_shape_idx, RID p_shape) override;
virtual void area_set_shape_transform(RID p_area, int p_shape_idx, const Transform &p_transform) override;
virtual int area_get_shape_count(RID p_area) const override;
virtual RID area_get_shape(RID p_area, int p_shape_idx) const override;
virtual Transform area_get_shape_transform(RID p_area, int p_shape_idx) const override;
virtual void area_remove_shape(RID p_area, int p_shape_idx) override;
virtual void area_clear_shapes(RID p_area) override;
virtual void area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) override;
virtual void area_attach_object_instance_id(RID p_area, ObjectID p_id) override;
virtual ObjectID area_get_object_instance_id(RID p_area) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// If you pass as p_area the SpaceBullet you can set some parameters as specified below
/// AREA_PARAM_GRAVITY
/// AREA_PARAM_GRAVITY_VECTOR
/// Otherwise you can set area parameters
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void area_set_param(RID p_area, AreaParameter p_param, const Variant &p_value) override;
virtual Variant area_get_param(RID p_area, AreaParameter p_param) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void area_set_transform(RID p_area, const Transform &p_transform) override;
virtual Transform area_get_transform(RID p_area) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void area_set_collision_mask(RID p_area, uint32_t p_mask) override;
virtual void area_set_collision_layer(RID p_area, uint32_t p_layer) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void area_set_monitorable(RID p_area, bool p_monitorable) override;
virtual void area_set_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) override;
virtual void area_set_area_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) override;
virtual void area_set_ray_pickable(RID p_area, bool p_enable) override;
virtual bool area_is_ray_pickable(RID p_area) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/* RIGID BODY API */
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID body_create(BodyMode p_mode = BODY_MODE_RIGID, bool p_init_sleeping = false) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_space(RID p_body, RID p_space) override;
virtual RID body_get_space(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_mode(RID p_body, BodyMode p_mode) override;
virtual BodyMode body_get_mode(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_add_shape(RID p_body, RID p_shape, const Transform &p_transform = Transform(), bool p_disabled = false) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
// Not supported, Please remove and add new shape
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_shape(RID p_body, int p_shape_idx, RID p_shape) override;
virtual void body_set_shape_transform(RID p_body, int p_shape_idx, const Transform &p_transform) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual int body_get_shape_count(RID p_body) const override;
virtual RID body_get_shape(RID p_body, int p_shape_idx) const override;
virtual Transform body_get_shape_transform(RID p_body, int p_shape_idx) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_remove_shape(RID p_body, int p_shape_idx) override;
virtual void body_clear_shapes(RID p_body) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
// Used for Rigid and Soft Bodies
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_attach_object_instance_id(RID p_body, ObjectID p_id) override;
virtual ObjectID body_get_object_instance_id(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_enable_continuous_collision_detection(RID p_body, bool p_enable) override;
virtual bool body_is_continuous_collision_detection_enabled(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_collision_layer(RID p_body, uint32_t p_layer) override;
virtual uint32_t body_get_collision_layer(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_collision_mask(RID p_body, uint32_t p_mask) override;
virtual uint32_t body_get_collision_mask(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// This is not supported by physics server
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_user_flags(RID p_body, uint32_t p_flags) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// This is not supported by physics server
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual uint32_t body_get_user_flags(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual void body_set_param(RID p_body, BodyParameter p_param, real_t p_value) override;
virtual real_t body_get_param(RID p_body, BodyParameter p_param) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_kinematic_safe_margin(RID p_body, real_t p_margin) override;
virtual real_t body_get_kinematic_safe_margin(RID p_body) const override;
Rewritten kinematic system
2017-11-07 15:22:09 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) override;
virtual Variant body_get_state(RID p_body, BodyState p_state) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_applied_force(RID p_body, const Vector3 &p_force) override;
virtual Vector3 body_get_applied_force(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_applied_torque(RID p_body, const Vector3 &p_torque) override;
virtual Vector3 body_get_applied_torque(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_add_central_force(RID p_body, const Vector3 &p_force) override;
virtual void body_add_force(RID p_body, const Vector3 &p_force, const Vector3 &p_position = Vector3()) override;
virtual void body_add_torque(RID p_body, const Vector3 &p_torque) override;
Modified RigidBody, PhysicsDirectBodyState, PhysicsServer, and their respective 2D counterparts to be more consistent and to include more useful methods. RigidBody: - Added add_central_force - Added add_force - Added add_torque - Added apply_central_impulse RigidBody2D: - Added add_central_force - Added add_torque - Added apply_central_impulse - Added apply_torque_impulse PhysicsDirectBodyState: - Added apply_central_impulse Physics2DDirectBodyState: - Added add_central_force - Added add_force - Added add_torque - Added apply_central_impulse - Added apply_impulse - Added apply_torque_impulse PhysicsServer: - Added body_add_force - Added body_add_torque - Added body_add_central_force - Added body_apply_central_impulse Physics2DServer: - Added body_add_torque - Added body_add_central_force - Added body_apply_central_impulse - Added body_apply_torque_impulse Also fixed some small bugs along the way
2018-07-24 09:49:12 +02:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_apply_central_impulse(RID p_body, const Vector3 &p_impulse) override;
virtual void body_apply_impulse(RID p_body, const Vector3 &p_impulse, const Vector3 &p_position = Vector3()) override;
virtual void body_apply_torque_impulse(RID p_body, const Vector3 &p_impulse) override;
virtual void body_set_axis_velocity(RID p_body, const Vector3 &p_axis_velocity) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_lock) override;
virtual bool body_is_axis_locked(RID p_body, BodyAxis p_axis) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_add_collision_exception(RID p_body, RID p_body_b) override;
virtual void body_remove_collision_exception(RID p_body, RID p_body_b) override;
virtual void body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_max_contacts_reported(RID p_body, int p_contacts) override;
virtual int body_get_max_contacts_reported(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual void body_set_contacts_reported_depth_threshold(RID p_body, real_t p_threshold) override;
virtual real_t body_get_contacts_reported_depth_threshold(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_omit_force_integration(RID p_body, bool p_omit) override;
virtual bool body_is_omitting_force_integration(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_force_integration_callback(RID p_body, Object *p_receiver, const StringName &p_method, const Variant &p_udata = Variant()) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void body_set_ray_pickable(RID p_body, bool p_enable) override;
virtual bool body_is_ray_pickable(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
// this function only works on physics process, errors and returns null otherwise
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual PhysicsDirectBodyState3D *body_get_direct_state(RID p_body) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual bool body_test_motion(RID p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, MotionResult *r_result = nullptr, bool p_exclude_raycast_shapes = true) override;
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual int body_test_ray_separation(RID p_body, const Transform &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, SeparationResult *r_results, int p_result_max, real_t p_margin = 0.001) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/* SOFT BODY API */
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID soft_body_create(bool p_init_sleeping = false) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_update_rendering_server(RID p_body, class SoftBodyRenderingServerHandler *p_rendering_server_handler) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_space(RID p_body, RID p_space) override;
virtual RID soft_body_get_space(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_mesh(RID p_body, const REF &p_mesh) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_collision_layer(RID p_body, uint32_t p_layer) override;
virtual uint32_t soft_body_get_collision_layer(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_collision_mask(RID p_body, uint32_t p_mask) override;
virtual uint32_t soft_body_get_collision_mask(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_add_collision_exception(RID p_body, RID p_body_b) override;
virtual void soft_body_remove_collision_exception(RID p_body, RID p_body_b) override;
virtual void soft_body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) override;
virtual Variant soft_body_get_state(RID p_body, BodyState p_state) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
/// Special function. This function has bad performance
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_transform(RID p_body, const Transform &p_transform) override;
virtual Vector3 soft_body_get_vertex_position(RID p_body, int vertex_index) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_ray_pickable(RID p_body, bool p_enable) override;
virtual bool soft_body_is_ray_pickable(RID p_body) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_simulation_precision(RID p_body, int p_simulation_precision) override;
virtual int soft_body_get_simulation_precision(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_total_mass(RID p_body, real_t p_total_mass) override;
virtual real_t soft_body_get_total_mass(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_linear_stiffness(RID p_body, real_t p_stiffness) override;
virtual real_t soft_body_get_linear_stiffness(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Make Servers truly Thread Safe -Rendering server now uses a split RID allocate/initialize internally, this allows generating RIDs immediately but initialization to happen later on the proper thread (as rendering APIs generally requiere to call on the right thread). -RenderingServerWrapMT is no more, multithreading is done in RenderingServerDefault. -Some functions like texture or mesh creation, when renderer supports it, can register and return immediately (so no waiting for server API to flush, and saving staging and command buffer memory). -3D physics server changed to be made multithread friendly. -Added PhysicsServer3DWrapMT to use 3D physics server from multiple threads. -Disablet Bullet (too much effort to make multithread friendly, this needs to be fixed eventually).
2021-02-09 17:19:03 +01:00
virtual void soft_body_set_angular_stiffness(RID p_body, real_t p_stiffness) override;
virtual real_t soft_body_get_angular_stiffness(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_volume_stiffness(RID p_body, real_t p_stiffness) override;
virtual real_t soft_body_get_volume_stiffness(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_pressure_coefficient(RID p_body, real_t p_pressure_coefficient) override;
virtual real_t soft_body_get_pressure_coefficient(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_pose_matching_coefficient(RID p_body, real_t p_pose_matching_coefficient) override;
virtual real_t soft_body_get_pose_matching_coefficient(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_damping_coefficient(RID p_body, real_t p_damping_coefficient) override;
virtual real_t soft_body_get_damping_coefficient(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_set_drag_coefficient(RID p_body, real_t p_drag_coefficient) override;
virtual real_t soft_body_get_drag_coefficient(RID p_body) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_move_point(RID p_body, int p_point_index, const Vector3 &p_global_position) override;
virtual Vector3 soft_body_get_point_global_position(RID p_body, int p_point_index) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual Vector3 soft_body_get_point_offset(RID p_body, int p_point_index) const override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void soft_body_remove_all_pinned_points(RID p_body) override;
virtual void soft_body_pin_point(RID p_body, int p_point_index, bool p_pin) override;
virtual bool soft_body_is_point_pinned(RID p_body, int p_point_index) override;
Implemented Soft body - Soft Body Physics node - Soft Body Rendering - Soft body Editor - Soft body importer
2017-11-21 01:36:32 +01:00
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/* JOINT API */
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual JointType joint_get_type(RID p_joint) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void joint_set_solver_priority(RID p_joint, int p_priority) override;
virtual int joint_get_solver_priority(RID p_joint) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void joint_disable_collisions_between_bodies(RID p_joint, const bool p_disable) override;
virtual bool joint_is_disabled_collisions_between_bodies(RID p_joint) const override;
Added physics API in order to enable/disable collisions between rigidbody attached to a joint with bullet physics bullet Fixes #16424
2018-02-05 18:20:26 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID joint_create_pin(RID p_body_A, const Vector3 &p_local_A, RID p_body_B, const Vector3 &p_local_B) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual void pin_joint_set_param(RID p_joint, PinJointParam p_param, real_t p_value) override;
virtual real_t pin_joint_get_param(RID p_joint, PinJointParam p_param) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) override;
virtual Vector3 pin_joint_get_local_a(RID p_joint) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) override;
virtual Vector3 pin_joint_get_local_b(RID p_joint) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID joint_create_hinge(RID p_body_A, const Transform &p_hinge_A, RID p_body_B, const Transform &p_hinge_B) override;
virtual RID joint_create_hinge_simple(RID p_body_A, const Vector3 &p_pivot_A, const Vector3 &p_axis_A, RID p_body_B, const Vector3 &p_pivot_B, const Vector3 &p_axis_B) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual void hinge_joint_set_param(RID p_joint, HingeJointParam p_param, real_t p_value) override;
virtual real_t hinge_joint_get_param(RID p_joint, HingeJointParam p_param) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag, bool p_value) override;
virtual bool hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// Reference frame is A
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID joint_create_slider(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual void slider_joint_set_param(RID p_joint, SliderJointParam p_param, real_t p_value) override;
virtual real_t slider_joint_get_param(RID p_joint, SliderJointParam p_param) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// Reference frame is A
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID joint_create_cone_twist(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual void cone_twist_joint_set_param(RID p_joint, ConeTwistJointParam p_param, real_t p_value) override;
virtual real_t cone_twist_joint_get_param(RID p_joint, ConeTwistJointParam p_param) const override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/// Reference frame is A
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual RID joint_create_generic_6dof(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual void generic_6dof_joint_set_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param, real_t p_value) override;
virtual real_t generic_6dof_joint_get_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag, bool p_enable) override;
virtual bool generic_6dof_joint_get_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
/* MISC */
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void free(RID p_rid) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void set_active(bool p_active) override {
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
active = p_active;
}
static bool singleton_isActive() {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
return static_cast<BulletPhysicsServer3D *>(get_singleton())->active;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
}
bool isActive() {
return active;
}
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void init() override;
Use real_t in physics code
2021-01-28 07:34:26 +01:00
virtual void step(real_t p_deltaTime) override;
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void flush_queries() override;
virtual void finish() override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual bool is_flushing_queries() const override { return false; }
-Make sure monitorable cant be flipped while flushing queries, fixes #17330 -Also added set_deferred, this was missing.
2018-11-16 12:49:26 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual int get_process_info(ProcessInfo p_info) override;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
Added BulletPhysics APIs to return internal objects and fixed a typo.
2020-06-21 18:29:45 +02:00
SpaceBullet *get_space(RID p_rid) const;
ShapeBullet *get_shape(RID p_rid) const;
CollisionObjectBullet *get_collision_object(RID p_object) const;
RigidCollisionObjectBullet *get_rigid_collision_object(RID p_object) const;
JointBullet *get_joint(RID p_rid) const;
Bullet physics engine implementation This is a bullet wrapper that allows Godot to use Bullet physics and benefit about all features. Also it support all specific Godot physics functionality like multi shape body, areas, RayShape, etc.. It improve the Joints, Trimesh shape, and add support to soft body even if Godot is not yet ready to it.
2017-11-04 20:52:59 +01:00
};
#endif
Reference in a new issue Copy permalink