+Vector<String> SpriteFrames::get_animation_names() const {

+

+ Vector<String> names;

+ for (const Map<StringName, Anim>::Element *E = animations.front(); E; E = E->next()) {

+ names.push_back(E->key());

+ }

+ names.sort();

+ return names;

+}

+

+ E->get().frames.write[i] = p_frames[i];

+ ClassDB::bind_method(D_METHOD("get_animation_names"), &SpriteFrames::get_animation_names);

+

+ Vector<String> get_animation_names() const;

+ E->get().frames.write[p_idx] = p_frame;

+ ERR_FAIL_COND(p_pitch_scale <= 0.0);

+ if (canvas_layer)

+ return canvas_layer->get_transform() * get_global_transform();

+ return get_viewport()->get_canvas_transform() * get_global_transform();

+ else

+ return get_global_transform();

+ if (Object::cast_to<Viewport>(n)) {

+ break;

+ }

+ friend class CanvasLayer;

+

+ Transform2D global_transform = get_global_transform_with_canvas();

+

+ Physics2DServer::get_singleton()->area_set_transform(rid, global_transform);

+ Physics2DServer::get_singleton()->body_set_state(rid, Physics2DServer::BODY_STATE_TRANSFORM, global_transform);

+

+ last_transform = global_transform;

+ Transform2D global_transform = get_global_transform_with_canvas();

+

+ if (only_update_transform_changes && global_transform == last_transform) {

+ return;

+ }

+

+ Physics2DServer::get_singleton()->area_set_transform(rid, global_transform);

+ Physics2DServer::get_singleton()->body_set_state(rid, Physics2DServer::BODY_STATE_TRANSFORM, global_transform);

+

+ last_transform = global_transform;

+ E->get().shapes.write[i].index -= 1;

+void CollisionObject2D::set_only_update_transform_changes(bool p_enable) {

+ only_update_transform_changes = p_enable;

+}

+

+ only_update_transform_changes = false;

+ Transform2D last_transform;

+ bool only_update_transform_changes; //this is used for sync physics in KinematicBody

+ void set_only_update_transform_changes(bool p_enable);

+

+ decomp.write[idx].resize(tp.GetNumPoints());

+ decomp.write[idx].write[i] = tp.GetPoint(i);

+ float g = draw_col.get_v();

+ points.write[i] = points_read[i];

+ ADD_PROPERTYNZ(PropertyInfo(Variant::INT, "texture_mode", PROPERTY_HINT_ENUM, "None,Tile,Stretch"), "set_texture_mode", "get_texture_mode");

+ BIND_ENUM_CONSTANT(LINE_TEXTURE_STRETCH);

+ LINE_TEXTURE_TILE,

+ LINE_TEXTURE_STRETCH

+ bool distance_required = _interpolate_color ||

+ texture_mode == Line2D::LINE_TEXTURE_TILE ||

+ texture_mode == Line2D::LINE_TEXTURE_STRETCH;

+ new_arc(pos0, pos_up0 - pos0, -Math_PI, color0, Rect2(0.f, 0.f, fmin(uvx0 * 2, 1.f), 1.f));

+ } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) {

+ uvx0 = current_distance0 / total_distance;

+ uvx1 = current_distance1 / total_distance;

+ } else if (texture_mode == Line2D::LINE_TEXTURE_STRETCH) {

+ uvx1 = current_distance1 / total_distance;

+ new_arc(pos1, pos_up1 - pos1, Math_PI, color, Rect2(uvx1 - 0.5f / tile_aspect, 0.f, 1.0f / tile_aspect, 1.f));

+#include "vector2.h"

+ p.edges.write[j] = e;

+ p.edges.write[j].P = C->get().pending.push_back(pending);

+ C->get().A->edges.write[C->get().A_edge].C = &p;

+ C->get().A->edges.write[C->get().A_edge].C_edge = j;

+ p.edges.write[j].C = C->get().A;

+ p.edges.write[j].C_edge = C->get().A_edge;

+ C->get().B->edges.write[C->get().B_edge].C = NULL;

+ C->get().B->edges.write[C->get().B_edge].C_edge = -1;

+ C->get().A->edges.write[C->get().A_edge].C = NULL;

+ C->get().A->edges.write[C->get().A_edge].C_edge = -1;

+ C->get().A->edges.write[C->get().A_edge].C = cp.polygon;

+ C->get().A->edges.write[C->get().A_edge].C_edge = cp.edge;

+ cp.polygon->edges.write[cp.edge].C = C->get().A;

+ cp.polygon->edges.write[cp.edge].C_edge = C->get().A_edge;

+ cp.polygon->edges.write[cp.edge].P = NULL;

+ path.write[0] = begin_point;

+ path.write[1] = end_point;

+ Polygon::Edge &e = p->edges.write[i];

+ path.write[path.size() - 1] = begin_point; // Replace first midpoint by the exact begin point

+ path.write[path.size() - 1] = end_point; // Replace last midpoint by the exact end point

+ polygons.write[i].indices = p_array[i];

+ outlines.write[i] = p_array[i];

+ outlines.write[p_idx] = p_outline;

+ vertices.write[i] = vr[i];

+ colors.write[i] = color;

+ ADD_PROPERTYNZ(PropertyInfo(Variant::REAL, "rotation_degrees", PROPERTY_HINT_RANGE, "-1080,1080,0.1,or_lesser,or_greater", PROPERTY_USAGE_EDITOR), "set_rotation_degrees", "get_rotation_degrees");

+#include "core/core_string_names.h"

+#include "math_funcs.h"

+#ifndef DISABLE_DEPRECATED

+ ERR_EXPLAIN("The method set_friction has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ physics_material_override.instance();

+ set_physics_material_override(physics_material_override);

+ }

+ physics_material_override->set_friction(p_friction);

+

+ ERR_EXPLAIN("The method get_friction has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ return 1;

+ }

+

+ return physics_material_override->get_friction();

+ ERR_EXPLAIN("The method set_bounce has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ physics_material_override.instance();

+ set_physics_material_override(physics_material_override);

+ }

+ physics_material_override->set_bounce(p_bounce);

+

+ ERR_EXPLAIN("The method get_bounce has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ return 0;

+ }

+

+ return physics_material_override->get_bounce();

+}

+#endif // DISABLE_DEPRECATED

+

+void StaticBody2D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {

+ if (physics_material_override.is_valid()) {

+ if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics"))

+ physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");

+ }

+

+ physics_material_override = p_physics_material_override;

+

+ if (physics_material_override.is_valid()) {

+ physics_material_override->connect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");

+ }

+ _reload_physics_characteristics();

+}

+

+Ref<PhysicsMaterial> StaticBody2D::get_physics_material_override() const {

+ return physics_material_override;

+

+#ifndef DISABLE_DEPRECATED

+#endif // DISABLE_DEPRECATED

+

+ ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &StaticBody2D::set_physics_material_override);

+ ClassDB::bind_method(D_METHOD("get_physics_material_override"), &StaticBody2D::get_physics_material_override);

+

+ ClassDB::bind_method(D_METHOD("_reload_physics_characteristics"), &StaticBody2D::_reload_physics_characteristics);

+#ifndef DISABLE_DEPRECATED

+#endif // DISABLE_DEPRECATED

+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "physics_material_override", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial"), "set_physics_material_override", "get_physics_material_override");

+void StaticBody2D::_reload_physics_characteristics() {

+ if (physics_material_override.is_null()) {

+ Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, 0);

+ Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, 1);

+ } else {

+ Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());

+ Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->computed_friction());

+ }

+}

+

+ return Physics2DServer::get_singleton()->body_test_motion(get_rid(), get_global_transform_with_canvas(), p_motion, p_infinite_inertia, p_margin, r);

+ set_global_transform(get_canvas_transform().affine_inverse() * state->get_transform());

+#ifndef DISABLE_DEPRECATED

+ ERR_EXPLAIN("The method set_friction has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+ if (physics_material_override.is_null()) {

+ physics_material_override.instance();

+ set_physics_material_override(physics_material_override);

+ }

+ physics_material_override->set_friction(p_friction);

+ ERR_EXPLAIN("The method get_friction has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ return 1;

+ }

+

+ return physics_material_override->get_friction();

+ ERR_EXPLAIN("The method set_bounce has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ physics_material_override.instance();

+ set_physics_material_override(physics_material_override);

+ }

+ physics_material_override->set_bounce(p_bounce);

+ ERR_EXPLAIN("The method get_bounce has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ return 0;

+ }

+

+ return physics_material_override->get_bounce();

+}

+#endif // DISABLE_DEPRECATED

+

+void RigidBody2D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {

+ if (physics_material_override.is_valid()) {

+ if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics"))

+ physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");

+ }

+

+ physics_material_override = p_physics_material_override;

+

+ if (physics_material_override.is_valid()) {

+ physics_material_override->connect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");

+ }

+ _reload_physics_characteristics();

+}

+

+Ref<PhysicsMaterial> RigidBody2D::get_physics_material_override() const {

+ return physics_material_override;

+void RigidBody2D::apply_central_impulse(const Vector2 &p_impulse) {

+ Physics2DServer::get_singleton()->body_apply_central_impulse(get_rid(), p_impulse);

+}

+

+void RigidBody2D::apply_torque_impulse(float p_torque) {

+ Physics2DServer::get_singleton()->body_apply_torque_impulse(get_rid(), p_torque);

+}

+

+void RigidBody2D::add_central_force(const Vector2 &p_force) {

+ Physics2DServer::get_singleton()->body_add_central_force(get_rid(), p_force);

+}

+

+void RigidBody2D::add_torque(const float p_torque) {

+ Physics2DServer::get_singleton()->body_add_torque(get_rid(), p_torque);

+}

+

+#ifndef DISABLE_DEPRECATED

+#endif // DISABLE_DEPRECATED

+

+ ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &RigidBody2D::set_physics_material_override);

+ ClassDB::bind_method(D_METHOD("get_physics_material_override"), &RigidBody2D::get_physics_material_override);

+

+ ClassDB::bind_method(D_METHOD("_reload_physics_characteristics"), &RigidBody2D::_reload_physics_characteristics);

+ ClassDB::bind_method(D_METHOD("apply_central_impulse", "impulse"), &RigidBody2D::apply_central_impulse);

+ ClassDB::bind_method(D_METHOD("apply_torque_impulse", "torque"), &RigidBody2D::apply_torque_impulse);

+ ClassDB::bind_method(D_METHOD("add_central_force", "force"), &RigidBody2D::add_central_force);

+ ClassDB::bind_method(D_METHOD("add_torque", "torque"), &RigidBody2D::add_torque);

+#ifndef DISABLE_DEPRECATED

+#endif // DISABLE_DEPRECATED

+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "physics_material_override", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial"), "set_physics_material_override", "get_physics_material_override");

+void RigidBody2D::_reload_physics_characteristics() {

+ if (physics_material_override.is_null()) {

+ Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, 0);

+ Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, 1);

+ } else {

+ Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());

+ Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->computed_friction());

+ }

+}

+

+Ref<KinematicCollision2D> KinematicBody2D::_move(const Vector2 &p_motion, bool p_infinite_inertia, bool p_exclude_raycast_shapes, bool p_test_only) {

+ if (move_and_collide(p_motion, p_infinite_inertia, col, p_exclude_raycast_shapes, p_test_only)) {

+bool KinematicBody2D::separate_raycast_shapes(bool p_infinite_inertia, Collision &r_collision) {

+ Physics2DServer::SeparationResult sep_res[8]; //max 8 rays

+

+ Transform2D gt = get_global_transform_with_canvas();

+

+ Vector2 recover;

+ int hits = Physics2DServer::get_singleton()->body_test_ray_separation(get_rid(), gt, p_infinite_inertia, recover, sep_res, 8, margin);

+ int deepest = -1;

+ float deepest_depth;

+ for (int i = 0; i < hits; i++) {

+ if (deepest == -1 || sep_res[i].collision_depth > deepest_depth) {

+ deepest = i;

+ deepest_depth = sep_res[i].collision_depth;

+ }

+ }

+

+ gt.elements[2] += recover;

+ set_global_transform(get_canvas_transform().affine_inverse() * gt);

+

+ if (deepest != -1) {

+ r_collision.collider = sep_res[deepest].collider_id;

+ r_collision.collider_metadata = sep_res[deepest].collider_metadata;

+ r_collision.collider_shape = sep_res[deepest].collider_shape;

+ r_collision.collider_vel = sep_res[deepest].collider_velocity;

+ r_collision.collision = sep_res[deepest].collision_point;

+ r_collision.normal = sep_res[deepest].collision_normal;

+ r_collision.local_shape = sep_res[deepest].collision_local_shape;

+ r_collision.travel = recover;

+ r_collision.remainder = Vector2();

+

+ return true;

+ } else {

+ return false;

+ }

+}

+

+bool KinematicBody2D::move_and_collide(const Vector2 &p_motion, bool p_infinite_inertia, Collision &r_collision, bool p_exclude_raycast_shapes, bool p_test_only) {

+

+ Transform2D gt = get_global_transform_with_canvas();

+ bool colliding = Physics2DServer::get_singleton()->body_test_motion(get_rid(), gt, p_motion, p_infinite_inertia, margin, &result, p_exclude_raycast_shapes);

+ r_collision.collider_rid = result.collider;

+ if (!p_test_only) {

+ gt.elements[2] += result.motion;

+ set_global_transform(get_canvas_transform().affine_inverse() * gt);

+ }

+//so, if you pass 45 as limit, avoid numerical precision erros when angle is 45.

+#define FLOOR_ANGLE_THRESHOLD 0.01

+

+Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_floor_direction, bool p_infinite_inertia, bool p_stop_on_slope, int p_max_slides, float p_floor_max_angle) {

+

+ Vector2 floor_motion = floor_velocity;

+ if (on_floor && on_floor_body.is_valid()) {

+ //this approach makes sure there is less delay between the actual body velocity and the one we saved

+ Physics2DDirectBodyState *bs = Physics2DServer::get_singleton()->body_get_direct_state(on_floor_body);

+ if (bs) {

+ floor_motion = bs->get_linear_velocity();

+ }

+ }

+ Vector2 motion = (floor_motion + p_linear_velocity) * get_physics_process_delta_time();

+ on_floor_body = RID();

+ Vector2 lv_n = p_linear_velocity.normalized();

+

+ bool found_collision = false;

+

+ for (int i = 0; i < 2; i++) {

+ bool collided;

+ if (i == 0) { //collide

+ collided = move_and_collide(motion, p_infinite_inertia, collision);

+ if (!collided) {

+ motion = Vector2(); //clear because no collision happened and motion completed

+ }

+ } else { //separate raycasts (if any)

+ collided = separate_raycast_shapes(p_infinite_inertia, collision);

+ if (collided) {

+ collision.remainder = motion; //keep

+ collision.travel = Vector2();

+ }

+ }

+ if (collided) {

+ found_collision = true;

+ }

+ if (collided) {

+ colliders.push_back(collision);

+ motion = collision.remainder;

+ bool is_on_slope = false;

+ if (p_floor_direction == Vector2()) {

+ //all is a wall

+ on_wall = true;

+ } else {

+ if (collision.normal.dot(p_floor_direction) >= Math::cos(p_floor_max_angle + FLOOR_ANGLE_THRESHOLD)) { //floor

+

+ on_floor = true;

+ on_floor_body = collision.collider_rid;

+ floor_velocity = collision.collider_vel;

+

+ if (p_stop_on_slope) {

+ if (Vector2() == lv_n + p_floor_direction) {

+ Transform2D gt = get_global_transform_with_canvas();

+ gt.elements[2] -= collision.travel;

+ set_global_transform(get_canvas_transform().affine_inverse() * gt);

+ return Vector2();

+ }

+ }

+

+ is_on_slope = true;

+

+ } else if (collision.normal.dot(-p_floor_direction) >= Math::cos(p_floor_max_angle + FLOOR_ANGLE_THRESHOLD)) { //ceiling

+ on_ceiling = true;

+ } else {

+ on_wall = true;

+ }

+

+ if (p_stop_on_slope && is_on_slope) {

+ motion = motion.slide(p_floor_direction);

+ lv = lv.slide(p_floor_direction);

+ Vector2 n = collision.normal;

+ motion = motion.slide(n);

+ lv = lv.slide(n);

+ if (p_stop_on_slope)

+ break;

+ }

+ if (!found_collision) {

+Vector2 KinematicBody2D::move_and_slide_with_snap(const Vector2 &p_linear_velocity, const Vector2 &p_snap, const Vector2 &p_floor_direction, bool p_infinite_inertia, bool p_stop_on_slope, int p_max_slides, float p_floor_max_angle) {

+

+ bool was_on_floor = on_floor;

+

+ Vector2 ret = move_and_slide(p_linear_velocity, p_floor_direction, p_infinite_inertia, p_stop_on_slope, p_max_slides, p_floor_max_angle);

+ if (!was_on_floor || p_snap == Vector2()) {

+ return ret;

+ }

+

+ Collision col;

+ Transform2D gt = get_global_transform_with_canvas();

+

+ if (move_and_collide(p_snap, p_infinite_inertia, col, false, true)) {

+ gt.elements[2] += col.travel;

+ if (p_floor_direction != Vector2() && Math::acos(p_floor_direction.normalized().dot(col.normal)) < p_floor_max_angle) {

+ on_floor = true;

+ on_floor_body = col.collider_rid;

+ floor_velocity = col.collider_vel;

+ }

+ set_global_transform(get_canvas_transform().affine_inverse() * gt);

+ }

+

+ return ret;

+}

+

+ slide_colliders.write[p_bounce].instance();

+ slide_colliders.write[p_bounce]->owner = this;

+ slide_colliders.write[p_bounce]->collision = colliders[p_bounce];

+void KinematicBody2D::set_sync_to_physics(bool p_enable) {

+

+ if (sync_to_physics == p_enable) {

+ return;

+ }

+ sync_to_physics = p_enable;

+ if (p_enable) {

+ Physics2DServer::get_singleton()->body_set_force_integration_callback(get_rid(), this, "_direct_state_changed");

+ set_only_update_transform_changes(true);

+ set_notify_local_transform(true);

+ } else {

+ Physics2DServer::get_singleton()->body_set_force_integration_callback(get_rid(), NULL, "");

+ set_only_update_transform_changes(false);

+ set_notify_local_transform(false);

+ }

+}

+

+bool KinematicBody2D::is_sync_to_physics_enabled() const {

+ return sync_to_physics;

+}

+

+void KinematicBody2D::_direct_state_changed(Object *p_state) {

+

+ if (!sync_to_physics)

+ return;

+

+ Physics2DDirectBodyState *state = Object::cast_to<Physics2DDirectBodyState>(p_state);

+

+ last_valid_transform = state->get_transform();

+ set_notify_local_transform(false);

+ set_global_transform(get_canvas_transform().affine_inverse() * last_valid_transform);

+ set_notify_local_transform(true);

+}

+

+void KinematicBody2D::_notification(int p_what) {

+ if (p_what == NOTIFICATION_ENTER_TREE) {

+ last_valid_transform = get_global_transform_with_canvas();

+ }

+

+ if (p_what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED) {

+ //used by sync to physics, send the new transform to the physics

+ Transform2D new_transform = get_global_transform_with_canvas();

+ Physics2DServer::get_singleton()->body_set_state(get_rid(), Physics2DServer::BODY_STATE_TRANSFORM, new_transform);

+ //but then revert changes

+ set_notify_local_transform(false);

+ set_global_transform(get_canvas_transform().affine_inverse() * last_valid_transform);

+ set_notify_local_transform(true);

+ }

+}

+ ClassDB::bind_method(D_METHOD("move_and_collide", "rel_vec", "infinite_inertia", "exclude_raycast_shapes", "test_only"), &KinematicBody2D::_move, DEFVAL(true), DEFVAL(true), DEFVAL(false));

+ ClassDB::bind_method(D_METHOD("move_and_slide", "linear_velocity", "floor_normal", "infinite_inertia", "stop_on_slope", "max_bounces", "floor_max_angle"), &KinematicBody2D::move_and_slide, DEFVAL(Vector2(0, 0)), DEFVAL(true), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)));

+ ClassDB::bind_method(D_METHOD("move_and_slide_with_snap", "linear_velocity", "snap", "floor_normal", "infinite_inertia", "stop_on_slope", "max_bounces", "floor_max_angle"), &KinematicBody2D::move_and_slide_with_snap, DEFVAL(Vector2(0, 0)), DEFVAL(true), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)));

+ ClassDB::bind_method(D_METHOD("set_sync_to_physics", "enable"), &KinematicBody2D::set_sync_to_physics);

+ ClassDB::bind_method(D_METHOD("is_sync_to_physics_enabled"), &KinematicBody2D::is_sync_to_physics_enabled);

+

+ ClassDB::bind_method(D_METHOD("_direct_state_changed"), &KinematicBody2D::_direct_state_changed);

+

+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "motion/sync_to_physics"), "set_sync_to_physics", "is_sync_to_physics_enabled");

+ sync_to_physics = false;

+ slide_colliders.write[i]->owner = NULL;

+#include "scene/resources/physics_material.h"

+ Ref<PhysicsMaterial> physics_material_override;

+#ifndef DISABLE_DEPRECATED

+#endif

+ void set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override);

+ Ref<PhysicsMaterial> get_physics_material_override() const;

+

+private:

+ void _reload_physics_characteristics();

+ Ref<PhysicsMaterial> physics_material_override;

+#ifndef DISABLE_DEPRECATED

+#endif

+

+ void set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override);

+ Ref<PhysicsMaterial> get_physics_material_override() const;

+ void apply_central_impulse(const Vector2 &p_impulse);

+ void apply_torque_impulse(float p_torque);

+ void add_central_force(const Vector2 &p_force);

+ void add_torque(float p_torque);

+

+private:

+ void _reload_physics_characteristics();

+ RID collider_rid;

+ RID on_floor_body;

+ bool sync_to_physics;

+

+ Ref<KinematicCollision2D> _move(const Vector2 &p_motion, bool p_infinite_inertia = true, bool p_exclude_raycast_shapes = true, bool p_test_only = false);

+ Transform2D last_valid_transform;

+ void _direct_state_changed(Object *p_state);

+

+ void _notification(int p_what);

+ bool move_and_collide(const Vector2 &p_motion, bool p_infinite_inertia, Collision &r_collision, bool p_exclude_raycast_shapes = true, bool p_test_only = false);

+

+ bool separate_raycast_shapes(bool p_infinite_inertia, Collision &r_collision);

+

+ Vector2 move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_floor_direction = Vector2(0, 0), bool p_infinite_inertia = true, bool p_stop_on_slope = false, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45));

+ Vector2 move_and_slide_with_snap(const Vector2 &p_linear_velocity, const Vector2 &p_snap, const Vector2 &p_floor_direction = Vector2(0, 0), bool p_infinite_inertia = true, bool p_stop_on_slope = false, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45));

+ void set_sync_to_physics(bool p_enable);

+ bool is_sync_to_physics_enabled() const;

+

+

+

+ points.write[i] = polyr[i] + offset;

+ SWAP(ep[6], points.write[highest_idx]);

+ points.write[i] = points[i - 7];

+ points.write[highest_idx + i + 1] = ep[i];

+ uvs.write[i] = texmat.xform(uvr[i]) / tex_size;

+ uvs.write[i] = texmat.xform(points[i]) / tex_size;

+ colors.write[i] = color_r[i];

+ colors.write[i] = color;

+ vertices.write[j] = points[loop[j]];

+ indices.write[from + j] = loop[sub_indices[j]];

+ bone_weights.write[p_index].weights = p_weights;

+ bone_weights.write[p_index].path = p_path;

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "texture_rotation_degrees", PROPERTY_HINT_RANGE, "-1080,1080,0.1,or_lesser,or_greater"), "set_texture_rotation_degrees", "get_texture_rotation_degrees");

+ if (dss->intersect_ray(gt.get_origin(), gt.xform(to), rr, exclude, collision_mask, collide_with_bodies, collide_with_areas)) {

+void RayCast2D::set_collide_with_areas(bool p_clip) {

+

+ collide_with_areas = p_clip;

+}

+

+bool RayCast2D::is_collide_with_areas_enabled() const {

+

+ return collide_with_areas;

+}

+

+void RayCast2D::set_collide_with_bodies(bool p_clip) {

+

+ collide_with_bodies = p_clip;

+}

+

+bool RayCast2D::is_collide_with_bodies_enabled() const {

+

+ return collide_with_bodies;

+}

+

+ ClassDB::bind_method(D_METHOD("set_collide_with_areas", "enable"), &RayCast2D::set_collide_with_areas);

+ ClassDB::bind_method(D_METHOD("is_collide_with_areas_enabled"), &RayCast2D::is_collide_with_areas_enabled);

+

+ ClassDB::bind_method(D_METHOD("set_collide_with_bodies", "enable"), &RayCast2D::set_collide_with_bodies);

+ ClassDB::bind_method(D_METHOD("is_collide_with_bodies_enabled"), &RayCast2D::is_collide_with_bodies_enabled);

+

+

+ ADD_GROUP("Collide With", "collide_with");

+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with_areas", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collide_with_areas", "is_collide_with_areas_enabled");

+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with_bodies", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collide_with_bodies", "is_collide_with_bodies_enabled");

+ collide_with_bodies = true;

+ collide_with_areas = false;

+ bool collide_with_areas;

+ bool collide_with_bodies;

+

+ void set_collide_with_areas(bool p_clip);

+ bool is_collide_with_areas_enabled() const;

+

+ void set_collide_with_bodies(bool p_clip);

+ bool is_collide_with_bodies_enabled() const;

+

+ Vector2 n_scale = n->get_scale();

+ if (is_inside_tree()) {

+ _update_remote();

+ }

+ _update_remote();

+ bones.write[i].rest_inverse = bones[i].bone->get_skeleton_rest().affine_inverse(); //bind pose

+ bones.write[i].bone->skeleton_index = i;

+ bones.write[i].parent_index = parent_bone->skeleton_index;

+ bones.write[i].parent_index = -1;

+ bones.write[i].accum_transform = bones[bones[i].parent_index].accum_transform * bones[i].bone->get_transform();

+ bones.write[i].accum_transform = bones[i].bone->get_transform();

+ ClassDB::bind_method(D_METHOD("get_bone", "idx"), &Skeleton2D::get_bone);

+ update_dirty_quadrants();

+void TileMap::update_dirty_quadrants() {

+ if (tile_set->tile_get_tile_mode(c.id) == TileSet::AUTO_TILE || tile_set->tile_get_tile_mode(c.id) == TileSet::ATLAS_TILE) {

+ if (tile_set->tile_get_tile_mode(c.id) == TileSet::AUTO_TILE || tile_set->tile_get_tile_mode(c.id) == TileSet::ATLAS_TILE) {

+ vertices.write[i] = vr[i];

+ colors.write[i] = debug_navigation_color;

+ if (tile_set->tile_get_tile_mode(c.id) == TileSet::AUTO_TILE || tile_set->tile_get_tile_mode(c.id) == TileSet::ATLAS_TILE) {

+ rect_cache = r_total;

+ call_deferred("update_dirty_quadrants");

+ if (tile_set->tile_get_tile_mode(id) == TileSet::AUTO_TILE || tile_set->tile_get_tile_mode(id) == TileSet::ATLAS_TILE) {

+ update_dirty_quadrants();

+Rect2 TileMap::_edit_get_rect() const {

+ const_cast<TileMap *>(this)->update_dirty_quadrants();

+ return rect_cache;

+}

+

+ ClassDB::bind_method(D_METHOD("set_celld", "position", "data"), &TileMap::set_celld);

+ ClassDB::bind_method(D_METHOD("update_dirty_quadrants"), &TileMap::update_dirty_quadrants);

+ virtual Rect2 _edit_get_rect() const;

+

+ void update_dirty_quadrants();

+

+ ERR_FAIL_COND(p_pitch_scale <= 0.0);

+ set_disable_scale(true);

+ set_disable_scale(true);

+#include "collision_object.h"

+#include "engine.h"

+ VisualServer::get_singleton()->camera_set_transform(camera, get_camera_transform());

+ Transform tr = get_global_transform().orthonormalized();

+ tr.origin += tr.basis.get_axis(1) * v_offset;

+ tr.origin += tr.basis.get_axis(0) * h_offset;

+ return tr;

+Vector<Vector3> Camera::get_near_plane_points() const {

+ if (!is_inside_tree()) {

+ ERR_EXPLAIN("Camera is not inside scene.");

+ ERR_FAIL_COND_V(!is_inside_tree(), Vector<Vector3>());

+ }

+

+ Size2 viewport_size = get_viewport()->get_visible_rect().size;

+

+ CameraMatrix cm;

+

+ if (mode == PROJECTION_ORTHOGONAL)

+ cm.set_orthogonal(size, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);

+ else

+ cm.set_perspective(fov, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);

+

+ Vector3 endpoints[8];

+ cm.get_endpoints(Transform(), endpoints);

+

+ Vector<Vector3> points;

+ points.push_back(Vector3());

+ for (int i = 0; i < 4; i++) {

+ points.push_back(endpoints[i + 4]);

+ }

+ return points;

+}

+

+

+ ClassDB::bind_method(D_METHOD("set_cull_mask_bit", "layer", "enable"), &Camera::set_cull_mask_bit);

+ ClassDB::bind_method(D_METHOD("get_cull_mask_bit", "layer"), &Camera::get_cull_mask_bit);

+

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "near", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01,or_greater"), "set_znear", "get_znear");

+void Camera::set_cull_mask_bit(int p_layer, bool p_enable) {

+ ERR_FAIL_INDEX(p_layer, 32);

+ if (p_enable) {

+ set_cull_mask(layers | (1 << p_layer));

+ } else {

+ set_cull_mask(layers & (~(1 << p_layer)));

+ }

+}

+

+bool Camera::get_cull_mask_bit(int p_layer) const {

+ ERR_FAIL_INDEX_V(p_layer, 32, false);

+ return (layers & (1 << p_layer));

+}

+

+ set_disable_scale(true);

+

+////////////////////////////////////////

+

+void ClippedCamera::set_margin(float p_margin) {

+ margin = p_margin;

+}

+float ClippedCamera::get_margin() const {

+ return margin;

+}

+void ClippedCamera::set_process_mode(ProcessMode p_mode) {

+

+ if (process_mode == p_mode) {

+ return;

+ }

+ set_process_internal(p_mode == CLIP_PROCESS_IDLE);

+ set_physics_process_internal(p_mode == CLIP_PROCESS_PHYSICS);

+}

+ClippedCamera::ProcessMode ClippedCamera::get_process_mode() const {

+ return process_mode;

+}

+

+Transform ClippedCamera::get_camera_transform() const {

+

+ Transform t = Camera::get_camera_transform();

+ t.origin += -t.basis.get_axis(Vector3::AXIS_Z).normalized() * clip_offset;

+ return t;

+}

+

+void ClippedCamera::_notification(int p_what) {

+ if (p_what == NOTIFICATION_INTERNAL_PROCESS || p_what == NOTIFICATION_INTERNAL_PHYSICS_PROCESS) {

+

+ Spatial *parent = Object::cast_to<Spatial>(get_parent());

+ if (!parent) {

+ return;

+ }

+

+ PhysicsDirectSpaceState *dspace = get_world()->get_direct_space_state();

+ ERR_FAIL_COND(!dspace); // most likely physics set to threads

+

+ Vector3 cam_fw = -get_global_transform().basis.get_axis(Vector3::AXIS_Z).normalized();

+ Vector3 cam_pos = get_global_transform().origin;

+ Vector3 parent_pos = parent->get_global_transform().origin;

+

+ Plane parent_plane(parent_pos, cam_fw);

+

+ if (parent_plane.is_point_over(cam_pos)) {

+ //cam is beyond parent plane

+ return;

+ }

+

+ Vector3 ray_from = parent_plane.project(cam_pos);

+

+ clip_offset = 0; //reset by defau;t

+

+ { //check if points changed

+ Vector<Vector3> local_points = get_near_plane_points();

+

+ bool all_equal = true;

+

+ for (int i = 0; i < 5; i++) {

+ if (points[i] != local_points[i]) {

+ all_equal = false;

+ break;

+ }

+ }

+

+ if (!all_equal) {

+ PhysicsServer::get_singleton()->shape_set_data(pyramid_shape, local_points);

+ points = local_points;

+ }

+ }

+

+ Transform xf = get_global_transform();

+ xf.origin = ray_from;

+ xf.orthonormalize();

+

+ float csafe, cunsafe;

+ if (dspace->cast_motion(pyramid_shape, xf, cam_pos - ray_from, margin, csafe, cunsafe, exclude, collision_mask, clip_to_bodies, clip_to_areas)) {

+ clip_offset = cam_pos.distance_to(ray_from + (cam_pos - ray_from).normalized() * csafe);

+ }

+

+ _update_camera();

+ }

+

+ if (p_what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED) {

+ update_gizmo();

+ }

+}

+

+void ClippedCamera::set_collision_mask(uint32_t p_mask) {

+

+ collision_mask = p_mask;

+}

+

+uint32_t ClippedCamera::get_collision_mask() const {

+

+ return collision_mask;

+}

+

+void ClippedCamera::set_collision_mask_bit(int p_bit, bool p_value) {

+

+ uint32_t mask = get_collision_mask();

+ if (p_value)

+ mask |= 1 << p_bit;

+ else

+ mask &= ~(1 << p_bit);

+ set_collision_mask(mask);

+}

+

+bool ClippedCamera::get_collision_mask_bit(int p_bit) const {

+

+ return get_collision_mask() & (1 << p_bit);

+}

+

+void ClippedCamera::add_exception_rid(const RID &p_rid) {

+

+ exclude.insert(p_rid);

+}

+

+void ClippedCamera::add_exception(const Object *p_object) {

+

+ ERR_FAIL_NULL(p_object);

+ const CollisionObject *co = Object::cast_to<CollisionObject>(p_object);

+ if (!co)

+ return;

+ add_exception_rid(co->get_rid());

+}

+

+void ClippedCamera::remove_exception_rid(const RID &p_rid) {

+

+ exclude.erase(p_rid);

+}

+

+void ClippedCamera::remove_exception(const Object *p_object) {

+

+ ERR_FAIL_NULL(p_object);

+ const CollisionObject *co = Object::cast_to<CollisionObject>(p_object);

+ if (!co)

+ return;

+ remove_exception_rid(co->get_rid());

+}

+

+void ClippedCamera::clear_exceptions() {

+

+ exclude.clear();

+}

+

+void ClippedCamera::set_clip_to_areas(bool p_clip) {

+

+ clip_to_areas = p_clip;

+}

+

+bool ClippedCamera::is_clip_to_areas_enabled() const {

+

+ return clip_to_areas;

+}

+

+void ClippedCamera::set_clip_to_bodies(bool p_clip) {

+

+ clip_to_bodies = p_clip;

+}

+

+bool ClippedCamera::is_clip_to_bodies_enabled() const {

+

+ return clip_to_bodies;

+}

+

+void ClippedCamera::_bind_methods() {

+

+ ClassDB::bind_method(D_METHOD("set_margin", "margin"), &ClippedCamera::set_margin);

+ ClassDB::bind_method(D_METHOD("get_margin"), &ClippedCamera::get_margin);

+

+ ClassDB::bind_method(D_METHOD("set_process_mode", "process_mode"), &ClippedCamera::set_process_mode);

+ ClassDB::bind_method(D_METHOD("get_process_mode"), &ClippedCamera::get_process_mode);

+

+ ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &ClippedCamera::set_collision_mask);

+ ClassDB::bind_method(D_METHOD("get_collision_mask"), &ClippedCamera::get_collision_mask);

+

+ ClassDB::bind_method(D_METHOD("set_collision_mask_bit", "bit", "value"), &ClippedCamera::set_collision_mask_bit);

+ ClassDB::bind_method(D_METHOD("get_collision_mask_bit", "bit"), &ClippedCamera::get_collision_mask_bit);

+

+ ClassDB::bind_method(D_METHOD("add_exception_rid", "rid"), &ClippedCamera::add_exception_rid);

+ ClassDB::bind_method(D_METHOD("add_exception", "node"), &ClippedCamera::add_exception);

+

+ ClassDB::bind_method(D_METHOD("remove_exception_rid", "rid"), &ClippedCamera::remove_exception_rid);

+ ClassDB::bind_method(D_METHOD("remove_exception", "node"), &ClippedCamera::remove_exception);

+

+ ClassDB::bind_method(D_METHOD("set_clip_to_areas", "enable"), &ClippedCamera::set_clip_to_areas);

+ ClassDB::bind_method(D_METHOD("is_clip_to_areas_enabled"), &ClippedCamera::is_clip_to_areas_enabled);

+

+ ClassDB::bind_method(D_METHOD("set_clip_to_bodies", "enable"), &ClippedCamera::set_clip_to_bodies);

+ ClassDB::bind_method(D_METHOD("is_clip_to_bodies_enabled"), &ClippedCamera::is_clip_to_bodies_enabled);

+

+ ClassDB::bind_method(D_METHOD("clear_exceptions"), &ClippedCamera::clear_exceptions);

+

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "margin", PROPERTY_HINT_RANGE, "0,32,0.01"), "set_margin", "get_margin");

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "process_mode", PROPERTY_HINT_ENUM, "Physics,Idle"), "set_process_mode", "get_process_mode");

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");

+

+ ADD_GROUP("Clip To", "clip_to");

+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "clip_to_areas", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_clip_to_areas", "is_clip_to_areas_enabled");

+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "clip_to_bodies", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_clip_to_bodies", "is_clip_to_bodies_enabled");

+

+ BIND_ENUM_CONSTANT(CLIP_PROCESS_PHYSICS);

+ BIND_ENUM_CONSTANT(CLIP_PROCESS_IDLE);

+}

+ClippedCamera::ClippedCamera() {

+ margin = 0;

+ clip_offset = 0;

+ process_mode = CLIP_PROCESS_PHYSICS;

+ set_physics_process_internal(true);

+ collision_mask = 1;

+ set_notify_local_transform(Engine::get_singleton()->is_editor_hint());

+ points.resize(5);

+ pyramid_shape = PhysicsServer::get_singleton()->shape_create(PhysicsServer::SHAPE_CONVEX_POLYGON);

+ clip_to_areas = false;

+ clip_to_bodies = true;

+}

+ClippedCamera::~ClippedCamera() {

+ PhysicsServer::get_singleton()->free(pyramid_shape);

+}

+ Vector<Vector3> get_near_plane_points() const;

+

+ void set_cull_mask_bit(int p_layer, bool p_enable);

+ bool get_cull_mask_bit(int p_layer) const;

+

+class ClippedCamera : public Camera {

+

+ GDCLASS(ClippedCamera, Camera);

+

+public:

+ enum ProcessMode {

+ CLIP_PROCESS_PHYSICS,

+ CLIP_PROCESS_IDLE,

+ };

+

+private:

+ ProcessMode process_mode;

+ RID pyramid_shape;

+ float margin;

+ float clip_offset;

+ uint32_t collision_mask;

+ bool clip_to_areas;

+ bool clip_to_bodies;

+

+ Set<RID> exclude;

+

+ Vector<Vector3> points;

+

+protected:

+ void _notification(int p_what);

+ static void _bind_methods();

+ virtual Transform get_camera_transform() const;

+

+public:

+ void set_clip_to_areas(bool p_clip);

+ bool is_clip_to_areas_enabled() const;

+

+ void set_clip_to_bodies(bool p_clip);

+ bool is_clip_to_bodies_enabled() const;

+

+ void set_margin(float p_margin);

+ float get_margin() const;

+

+ void set_process_mode(ProcessMode p_mode);

+ ProcessMode get_process_mode() const;

+

+ void set_collision_mask(uint32_t p_mask);

+ uint32_t get_collision_mask() const;

+

+ void set_collision_mask_bit(int p_bit, bool p_value);

+ bool get_collision_mask_bit(int p_bit) const;

+

+ void add_exception_rid(const RID &p_rid);

+ void add_exception(const Object *p_object);

+ void remove_exception_rid(const RID &p_rid);

+ void remove_exception(const Object *p_object);

+ void clear_exceptions();

+

+ ClippedCamera();

+ ~ClippedCamera();

+};

+

+VARIANT_ENUM_CAST(ClippedCamera::ProcessMode);

+ E->get().shapes.write[i].index -= 1;

+

+protected:

+ VS::get_singleton()->instance_geometry_set_flag(get_instance(), VS::INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE, true);

+

+ p_delta *= speed_scale;

+

+ float restart_time = (float(i) / float(pcount)) * lifetime;

+ p.custom[1] = p.time / lifetime;

+ VS::get_singleton()->instance_geometry_set_flag(get_instance(), VS::INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE, true);

+ VS::get_singleton()->instance_geometry_set_flag(get_instance(), VS::INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE, false);

+ VS::get_singleton()->instance_geometry_set_flag(get_instance(), VS::INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE, false);

+

+ set_disable_scale(true);

+ set_disable_scale(true);

+

+ materials.write[p_surface] = p_material;

+protected:

+ p.edges.write[j] = e;

+ p.edges.write[j].P = C->get().pending.push_back(pending);

+ C->get().A->edges.write[C->get().A_edge].C = &p;

+ C->get().A->edges.write[C->get().A_edge].C_edge = j;

+ p.edges.write[j].C = C->get().A;

+ p.edges.write[j].C_edge = C->get().A_edge;

+ C->get().B->edges.write[C->get().B_edge].C = NULL;

+ C->get().B->edges.write[C->get().B_edge].C_edge = -1;

+ C->get().A->edges.write[C->get().A_edge].C = NULL;

+ C->get().A->edges.write[C->get().A_edge].C_edge = -1;

+ C->get().A->edges.write[C->get().A_edge].C = cp.polygon;

+ C->get().A->edges.write[C->get().A_edge].C_edge = cp.edge;

+ cp.polygon->edges.write[cp.edge].C = C->get().A;

+ cp.polygon->edges.write[cp.edge].C_edge = C->get().A_edge;

+ cp.polygon->edges.write[cp.edge].P = NULL;

+ path.write[0] = begin_point;

+ path.write[1] = end_point;

+ Polygon::Edge &e = p->edges.write[i];

+ vi.write[0] = r[j + 0] + from;

+ vi.write[1] = r[j + 1] + from;

+ vi.write[2] = r[j + 2] + from;

+ polygons.write[i].indices = p_array[i];

+ draw_passes.write[p_pass] = p_mesh;

+#include "core/core_string_names.h"

+ CollisionObject *collision_object = Object::cast_to<CollisionObject>(p_node);

+ if (!collision_object) {

+ ERR_EXPLAIN("Collision exception only works between two CollisionObject");

+ ERR_FAIL_COND(!collision_object);

+ PhysicsServer::get_singleton()->body_add_collision_exception(get_rid(), collision_object->get_rid());

+ CollisionObject *collision_object = Object::cast_to<CollisionObject>(p_node);

+ if (!collision_object) {

+ ERR_EXPLAIN("Collision exception only works between two CollisionObject");

+ ERR_FAIL_COND(!collision_object);

+ PhysicsServer::get_singleton()->body_remove_collision_exception(get_rid(), collision_object->get_rid());

+#ifndef DISABLE_DEPRECATED

+ ERR_EXPLAIN("The method set_friction has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ physics_material_override.instance();

+ set_physics_material_override(physics_material_override);

+ }

+

+ physics_material_override->set_friction(p_friction);

+

+ ERR_EXPLAIN("The method get_friction has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ return 1;

+ }

+

+ return physics_material_override->get_friction();

+ ERR_EXPLAIN("The method set_bounce has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ physics_material_override.instance();

+ set_physics_material_override(physics_material_override);

+ }

+ physics_material_override->set_bounce(p_bounce);

+

+ ERR_EXPLAIN("The method get_bounce has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+

+ if (physics_material_override.is_null()) {

+ return 0;

+ }

+

+ return physics_material_override->get_bounce();

+}

+#endif

+

+void StaticBody::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {

+ if (physics_material_override.is_valid()) {

+ if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics"))

+ physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");

+ }

+

+ physics_material_override = p_physics_material_override;

+

+ if (physics_material_override.is_valid()) {

+ physics_material_override->connect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");

+ }

+ _reload_physics_characteristics();

+}

+

+Ref<PhysicsMaterial> StaticBody::get_physics_material_override() const {

+ return physics_material_override;

+#ifndef DISABLE_DEPRECATED

+#endif // DISABLE_DEPRECATED

+

+ ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &StaticBody::set_physics_material_override);

+ ClassDB::bind_method(D_METHOD("get_physics_material_override"), &StaticBody::get_physics_material_override);

+

+ ClassDB::bind_method(D_METHOD("_reload_physics_characteristics"), &StaticBody::_reload_physics_characteristics);

+#ifndef DISABLE_DEPRECATED

+#endif // DISABLE_DEPRECATED

+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "physics_material_override", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial"), "set_physics_material_override", "get_physics_material_override");

+StaticBody::~StaticBody() {}

+

+void StaticBody::_reload_physics_characteristics() {

+ if (physics_material_override.is_null()) {

+ PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, 0);

+ PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, 1);

+ } else {

+ PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());

+ PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->computed_friction());

+ }

+#ifndef DISABLE_DEPRECATED

+ ERR_EXPLAIN("The method set_friction has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+ if (physics_material_override.is_null()) {

+ physics_material_override.instance();

+ set_physics_material_override(physics_material_override);

+ }

+ physics_material_override->set_friction(p_friction);

+ ERR_EXPLAIN("The method get_friction has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+ if (physics_material_override.is_null()) {

+ return 1;

+ }

+

+ return physics_material_override->get_friction();

+ ERR_EXPLAIN("The method set_bounce has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+ if (physics_material_override.is_null()) {

+ physics_material_override.instance();

+ set_physics_material_override(physics_material_override);

+ }

+ physics_material_override->set_bounce(p_bounce);

+ ERR_EXPLAIN("The method get_bounce has been deprecated and will be removed in the future, use physical material")

+ WARN_DEPRECATED

+ if (physics_material_override.is_null()) {

+ return 0;

+ }

+ return physics_material_override->get_bounce();

+}

+#endif // DISABLE_DEPRECATED

+

+void RigidBody::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {

+ if (physics_material_override.is_valid()) {

+ if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics"))

+ physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");

+ }

+

+ physics_material_override = p_physics_material_override;

+

+ if (physics_material_override.is_valid()) {

+ physics_material_override->connect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");

+ }

+ _reload_physics_characteristics();

+}

+

+Ref<PhysicsMaterial> RigidBody::get_physics_material_override() const {

+ return physics_material_override;

+void RigidBody::add_central_force(const Vector3 &p_force) {

+ PhysicsServer::get_singleton()->body_add_central_force(get_rid(), p_force);

+}

+

+void RigidBody::add_force(const Vector3 &p_force, const Vector3 &p_pos) {

+ PhysicsServer::get_singleton()->body_add_force(get_rid(), p_force, p_pos);

+}

+

+void RigidBody::add_torque(const Vector3 &p_torque) {

+ PhysicsServer::get_singleton()->body_add_torque(get_rid(), p_torque);

+}

+

+void RigidBody::apply_central_impulse(const Vector3 &p_impulse) {

+ PhysicsServer::get_singleton()->body_apply_central_impulse(get_rid(), p_impulse);

+}

+

+#ifndef DISABLE_DEPRECATED

+#endif // DISABLE_DEPRECATED

+

+ ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &RigidBody::set_physics_material_override);

+ ClassDB::bind_method(D_METHOD("get_physics_material_override"), &RigidBody::get_physics_material_override);

+

+ ClassDB::bind_method(D_METHOD("_reload_physics_characteristics"), &RigidBody::_reload_physics_characteristics);

+

+ ClassDB::bind_method(D_METHOD("add_central_force", "force"), &RigidBody::add_central_force);

+ ClassDB::bind_method(D_METHOD("add_force", "force", "position"), &RigidBody::add_force);

+ ClassDB::bind_method(D_METHOD("add_torque", "torque"), &RigidBody::add_torque);

+

+ ClassDB::bind_method(D_METHOD("apply_central_impulse", "impulse"), &RigidBody::apply_central_impulse);

+#ifndef DISABLE_DEPRECATED

+#endif // DISABLE_DEPRECATED

+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "physics_material_override", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial"), "set_physics_material_override", "get_physics_material_override");

+

+void RigidBody::_reload_physics_characteristics() {

+ if (physics_material_override.is_null()) {

+ PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, 0);

+ PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, 1);

+ } else {

+ PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());

+ PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->computed_friction());

+ }

+}

+

+Ref<KinematicCollision> KinematicBody::_move(const Vector3 &p_motion, bool p_infinite_inertia, bool p_test_only) {

+ if (move_and_collide(p_motion, p_infinite_inertia, col, p_test_only)) {

+bool KinematicBody::move_and_collide(const Vector3 &p_motion, bool p_infinite_inertia, Collision &r_collision, bool p_test_only) {

+ r_collision.collider_rid = result.collider;

+ if (!p_test_only) {

+ gt.origin += result.motion;

+ set_global_transform(gt);

+ }

+//so, if you pass 45 as limit, avoid numerical precision erros when angle is 45.

+#define FLOOR_ANGLE_THRESHOLD 0.01

+

+Vector3 KinematicBody::move_and_slide(const Vector3 &p_linear_velocity, const Vector3 &p_floor_direction, bool p_stop_on_slope, int p_max_slides, float p_floor_max_angle, bool p_infinite_inertia) {

+ Vector3 lv_n = p_linear_velocity.normalized();

+

+ bool found_collision = false;

+ int test_type = 0;

+ do {

+ bool collided;

+ if (test_type == 0) { //collide

+ collided = move_and_collide(motion, p_infinite_inertia, collision);

+ if (!collided) {

+ motion = Vector3(); //clear because no collision happened and motion completed

+ }

+ collided = separate_raycast_shapes(p_infinite_inertia, collision);

+ if (collided) {

+ collision.remainder = motion; //keep

+ collision.travel = Vector3();

+ }

+ }

+ if (collided) {

+ found_collision = true;

+ }

+ if (collided) {

+ colliders.push_back(collision);

+ motion = collision.remainder;

+

+ bool is_on_slope = false;

+ if (p_floor_direction == Vector3()) {

+ //all is a wall

+ } else {

+ if (collision.normal.dot(p_floor_direction) >= Math::cos(p_floor_max_angle + FLOOR_ANGLE_THRESHOLD)) { //floor

+

+ on_floor = true;

+ on_floor_body = collision.collider_rid;

+ floor_velocity = collision.collider_vel;

+

+ if (p_stop_on_slope) {

+ if (Vector3() == lv_n + p_floor_direction) {

+ Transform gt = get_global_transform();

+ gt.origin -= collision.travel;

+ set_global_transform(gt);

+ return Vector3();

+ }

+ }

+

+ is_on_slope = true;

+

+ } else if (collision.normal.dot(-p_floor_direction) >= Math::cos(p_floor_max_angle + FLOOR_ANGLE_THRESHOLD)) { //ceiling

+ on_ceiling = true;

+ } else {

+ on_wall = true;

+ }

+ if (p_stop_on_slope && is_on_slope) {

+ motion = motion.slide(p_floor_direction);

+ lv = lv.slide(p_floor_direction);

+ } else {

+ Vector3 n = collision.normal;

+ motion = motion.slide(n);

+ lv = lv.slide(n);

+ }

+ for (int i = 0; i < 3; i++) {

+ if (locked_axis & (1 << i)) {

+ lv[i] = 0;

+ }

+ ++test_type;

+ } while (!p_stop_on_slope && test_type < 2);

+ if (!found_collision || motion == Vector3())

+ --p_max_slides;

+Vector3 KinematicBody::move_and_slide_with_snap(const Vector3 &p_linear_velocity, const Vector3 &p_snap, const Vector3 &p_floor_direction, bool p_infinite_inertia, bool p_stop_on_slope, int p_max_slides, float p_floor_max_angle) {

+

+ bool was_on_floor = on_floor;

+

+ Vector3 ret = move_and_slide(p_linear_velocity, p_floor_direction, p_stop_on_slope, p_max_slides, p_floor_max_angle, p_infinite_inertia);

+ if (!was_on_floor || p_snap == Vector3()) {

+ return ret;

+ }

+

+ Collision col;

+ Transform gt = get_global_transform();

+

+ if (move_and_collide(p_snap, p_infinite_inertia, col, true)) {

+ gt.origin += col.travel;

+ if (p_floor_direction != Vector3() && Math::acos(p_floor_direction.normalized().dot(col.normal)) < p_floor_max_angle) {

+ on_floor = true;

+ on_floor_body = col.collider_rid;

+ floor_velocity = col.collider_vel;

+ }

+ set_global_transform(gt);

+ }

+

+ return ret;

+}

+

+

+bool KinematicBody::separate_raycast_shapes(bool p_infinite_inertia, Collision &r_collision) {

+

+ PhysicsServer::SeparationResult sep_res[8]; //max 8 rays

+

+ Transform gt = get_global_transform();

+

+ Vector3 recover;

+ int hits = PhysicsServer::get_singleton()->body_test_ray_separation(get_rid(), gt, p_infinite_inertia, recover, sep_res, 8, margin);

+ int deepest = -1;

+ float deepest_depth;

+ for (int i = 0; i < hits; i++) {

+ if (deepest == -1 || sep_res[i].collision_depth > deepest_depth) {

+ deepest = i;

+ deepest_depth = sep_res[i].collision_depth;

+ }

+ }

+

+ gt.origin += recover;

+ set_global_transform(gt);

+

+ if (deepest != -1) {

+ r_collision.collider = sep_res[deepest].collider_id;

+ r_collision.collider_metadata = sep_res[deepest].collider_metadata;

+ r_collision.collider_shape = sep_res[deepest].collider_shape;

+ r_collision.collider_vel = sep_res[deepest].collider_velocity;

+ r_collision.collision = sep_res[deepest].collision_point;

+ r_collision.normal = sep_res[deepest].collision_normal;

+ r_collision.local_shape = sep_res[deepest].collision_local_shape;

+ r_collision.travel = recover;

+ r_collision.remainder = Vector3();

+

+ return true;

+ } else {

+ return false;

+ }

+}

+

+ slide_colliders.write[p_bounce].instance();

+ slide_colliders.write[p_bounce]->owner = this;

+ slide_colliders.write[p_bounce]->collision = colliders[p_bounce];

+ ClassDB::bind_method(D_METHOD("move_and_collide", "rel_vec", "infinite_inertia", "test_only"), &KinematicBody::_move, DEFVAL(true), DEFVAL(false));

+ ClassDB::bind_method(D_METHOD("move_and_slide", "linear_velocity", "floor_normal", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody::move_and_slide, DEFVAL(Vector3(0, 0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)), DEFVAL(true));

+ ClassDB::bind_method(D_METHOD("move_and_slide_with_snap", "linear_velocity", "snap", "floor_normal", "infinite_inertia", "stop_on_slope", "max_bounces", "floor_max_angle"), &KinematicBody::move_and_slide_with_snap, DEFVAL(Vector3(0, 0, 0)), DEFVAL(true), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)));

+ ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "move_lock_x", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_axis_lock", "get_axis_lock", PhysicsServer::BODY_AXIS_LINEAR_X);

+ ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "move_lock_y", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_axis_lock", "get_axis_lock", PhysicsServer::BODY_AXIS_LINEAR_Y);

+ ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "move_lock_z", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_axis_lock", "get_axis_lock", PhysicsServer::BODY_AXIS_LINEAR_Z);

+ slide_colliders.write[i]->owner = NULL;

+ ClassDB::bind_method(D_METHOD("get_bone_id"), &PhysicalBone::get_bone_id);

+

+

+#include "scene/resources/physics_material.h"

+ Ref<PhysicsMaterial> physics_material_override;

+#ifndef DISABLE_DEPRECATED

+#endif

+

+ void set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override);

+ Ref<PhysicsMaterial> get_physics_material_override() const;

+

+private:

+ void _reload_physics_characteristics();

+ Ref<PhysicsMaterial> physics_material_override;

+#ifndef DISABLE_DEPRECATED

+#endif

+

+ void set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override);

+ Ref<PhysicsMaterial> get_physics_material_override() const;

+ void add_central_force(const Vector3 &p_force);

+ void add_force(const Vector3 &p_force, const Vector3 &p_pos);

+ void add_torque(const Vector3 &p_torque);

+

+ void apply_central_impulse(const Vector3 &p_impulse);

+

+private:

+ void _reload_physics_characteristics();

+ RID collider_rid;

+ RID on_floor_body;

+ Ref<KinematicCollision> _move(const Vector3 &p_motion, bool p_infinite_inertia = true, bool p_test_only = false);

+ bool move_and_collide(const Vector3 &p_motion, bool p_infinite_inertia, Collision &r_collisionz, bool p_test_only = false);

+ bool separate_raycast_shapes(bool p_infinite_inertia, Collision &r_collision);

+

+ Vector3 move_and_slide(const Vector3 &p_linear_velocity, const Vector3 &p_floor_direction = Vector3(0, 0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45), bool p_infinite_inertia = true);

+ Vector3 move_and_slide_with_snap(const Vector3 &p_linear_velocity, const Vector3 &p_snap, const Vector3 &p_floor_direction = Vector3(0, 0, 0), bool p_infinite_inertia = true, bool p_stop_on_slope = false, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45));

+

+ if (dss->intersect_ray(gt.get_origin(), gt.xform(to), rr, exclude, collision_mask, collide_with_bodies, collide_with_areas)) {

+void RayCast::set_collide_with_areas(bool p_clip) {

+

+ collide_with_areas = p_clip;

+}

+

+bool RayCast::is_collide_with_areas_enabled() const {

+

+ return collide_with_areas;

+}

+

+void RayCast::set_collide_with_bodies(bool p_clip) {

+

+ collide_with_bodies = p_clip;

+}

+

+bool RayCast::is_collide_with_bodies_enabled() const {

+

+ return collide_with_bodies;

+}

+

+ ClassDB::bind_method(D_METHOD("set_collide_with_areas", "enable"), &RayCast::set_collide_with_areas);

+ ClassDB::bind_method(D_METHOD("is_collide_with_areas_enabled"), &RayCast::is_collide_with_areas_enabled);

+

+ ClassDB::bind_method(D_METHOD("set_collide_with_bodies", "enable"), &RayCast::set_collide_with_bodies);

+ ClassDB::bind_method(D_METHOD("is_collide_with_bodies_enabled"), &RayCast::is_collide_with_bodies_enabled);

+

+

+ ADD_GROUP("Collide With", "collide_with");

+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with_areas", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collide_with_areas", "is_collide_with_areas_enabled");

+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collide_with_bodies", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collide_with_bodies", "is_collide_with_bodies_enabled");

+ collide_with_areas = false;

+ collide_with_bodies = true;

+ bool collide_with_areas;

+ bool collide_with_bodies;

+

+ void set_collide_with_areas(bool p_clip);

+ bool is_collide_with_areas_enabled() const;

+

+ void set_collide_with_bodies(bool p_clip);

+ bool is_collide_with_bodies_enabled() const;

+

+ set_disable_scale(true);

+ if (is_inside_tree()) {

+ _update_remote();

+ }

+ bones.write[which].nodes_bound.clear();

+ p_list->push_back(PropertyInfo(Variant::INT, prep + "parent", PROPERTY_HINT_RANGE, "-1," + itos(bones.size() - 1) + ",1"));

+void Skeleton::_update_process_order() {

+

+ if (!process_order_dirty)

+ return;

+

+ Bone *bonesptr = bones.ptrw();

+ int len = bones.size();

+

+ process_order.resize(len);

+ int *order = process_order.ptrw();

+ for (int i = 0; i < len; i++) {

+

+ if (bonesptr[i].parent >= len) {

+ //validate this just in case

+ ERR_PRINTS("Bone " + itos(i) + " has invalid parent: " + itos(bonesptr[i].parent));

+ bonesptr[i].parent = -1;

+ }

+ order[i] = i;

+ bonesptr[i].sort_index = i;

+ }

+ //now check process order

+ int pass_count = 0;

+ while (pass_count < len * len) {

+ //using bubblesort because of simplicity, it wont run every frame though.

+ //bublesort worst case is O(n^2), and this may be an infinite loop if cyclic

+ bool swapped = false;

+ for (int i = 0; i < len; i++) {

+ int parent_idx = bonesptr[order[i]].parent;

+ if (parent_idx < 0)

+ continue; //do nothing because it has no parent

+ //swap indices

+ int parent_order = bonesptr[parent_idx].sort_index;

+ if (parent_order > i) {

+ bonesptr[order[i]].sort_index = parent_order;

+ bonesptr[parent_idx].sort_index = i;

+ //swap order

+ SWAP(order[i], order[parent_order]);

+ swapped = true;

+ }

+ }

+

+ if (!swapped)

+ break;

+ pass_count++;

+ }

+

+ if (pass_count == len * len) {

+ ERR_PRINT("Skeleton parenthood graph is cyclic");

+ }

+

+ process_order_dirty = false;

+}

+

+ Bone *bonesptr = bones.ptrw();

+ _update_process_order();

+

+ const int *order = process_order.ptr();

+

+ Bone &b = bonesptr[order[i]];

+ Bone &b = bonesptr[order[i]];

+ Bone &b = bonesptr[order[i]];

+ ERR_FAIL_COND(bones[i].name == p_name);

+ process_order_dirty = true;

+ ERR_FAIL_COND(p_parent != -1 && (p_parent < 0));

+ bones.write[p_bone].parent = p_parent;

+ process_order_dirty = true;

+ _update_process_order();

+

+ bones.write[p_bone].rest = bones[parent].rest * bones[p_bone].rest;

+ bones.write[p_bone].parent = -1;

+ bones.write[p_bone].rest_global_inverse = bones[p_bone].rest.affine_inverse(); //same thing

+ process_order_dirty = true;

+ bones.write[p_bone].ignore_animation = p_ignore;

+ bones.write[p_bone].disable_rest = p_disable;

+ bones.write[p_bone].rest = p_rest;

+ bones.write[p_bone].enabled = p_enabled;

+ for (const List<uint32_t>::Element *E = bones[p_bone].nodes_bound.front(); E; E = E->next()) {

+ bones.write[p_bone].nodes_bound.push_back(id);

+ bones.write[p_bone].nodes_bound.erase(id);

+ process_order_dirty = true;

+

+ bones.write[p_bone].pose = p_pose;

+ bones.write[p_bone].custom_pose_enable = (p_custom_pose != Transform());

+ bones.write[p_bone].custom_pose = p_custom_pose;

+int Skeleton::get_process_order(int p_idx) {

+ ERR_FAIL_INDEX_V(p_idx, bones.size(), -1);

+ _update_process_order();

+ return process_order[p_idx];

+}

+

+ _update_process_order();

+ for (int i = bones.size() - 1; i >= 0; i--) {

+ int idx = process_order[i];

+ if (bones[idx].parent >= 0) {

+ set_bone_rest(idx, bones[bones[idx].parent].rest.affine_inverse() * bones[idx].rest);

+ }

+ bones.write[p_bone].physical_bone = p_physical_bone;

+ bones.write[p_bone].physical_bone = NULL;

+ PhysicalBone *parent_pb = _get_physical_bone_parent(i);

+ if (parent_pb != bones[i].physical_bone) {

+ bones.write[i].cache_parent_physical_bone = parent_pb;

+ if (bones[i].physical_bone)

+ bones[i].physical_bone->_on_bone_parent_changed();

+ }

+ sim_bones.write[c++] = bone_id;

+ ClassDB::bind_method(D_METHOD("set_bone_ignore_animation", "bone", "ignore"), &Skeleton::set_bone_ignore_animation);

+

+ process_order_dirty = true;

+typedef int BoneId;

+

+ int sort_index; //used for re-sorting process order

+ Vector<int> process_order;

+ bool process_order_dirty;

+ // bind helpers

+ void _update_process_order();

+

+ int get_process_order(int p_idx);

+/*************************************************************************/

+/* soft_physics_body.cpp */

+/* Author: AndreaCatania */

+/*************************************************************************/

+/* This file is part of: */

+/* GODOT ENGINE */

+/* http://www.godotengine.org */

+/*************************************************************************/

+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */

+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */

+/* */

+/* 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. */

+/*************************************************************************/

+

+#include "soft_body.h"

+#include "os/os.h"

+#include "scene/3d/collision_object.h"

+#include "scene/3d/skeleton.h"

+#include "servers/physics_server.h"

+

+SoftBodyVisualServerHandler::SoftBodyVisualServerHandler() {}

+

+void SoftBodyVisualServerHandler::prepare(RID p_mesh, int p_surface) {

+ clear();

+

+ ERR_FAIL_COND(!p_mesh.is_valid());

+

+ mesh = p_mesh;

+ surface = p_surface;

+

+ const uint32_t surface_format = VS::get_singleton()->mesh_surface_get_format(mesh, surface);

+ const int surface_vertex_len = VS::get_singleton()->mesh_surface_get_array_len(mesh, p_surface);

+ const int surface_index_len = VS::get_singleton()->mesh_surface_get_array_index_len(mesh, p_surface);

+ uint32_t surface_offsets[VS::ARRAY_MAX];

+

+ buffer = VS::get_singleton()->mesh_surface_get_array(mesh, surface);

+ stride = VS::get_singleton()->mesh_surface_make_offsets_from_format(surface_format, surface_vertex_len, surface_index_len, surface_offsets);

+ offset_vertices = surface_offsets[VS::ARRAY_VERTEX];

+ offset_normal = surface_offsets[VS::ARRAY_NORMAL];

+}

+

+void SoftBodyVisualServerHandler::clear() {

+

+ if (mesh.is_valid()) {

+ buffer.resize(0);

+ }

+

+ mesh = RID();

+}

+

+void SoftBodyVisualServerHandler::open() {

+ write_buffer = buffer.write();

+}

+

+void SoftBodyVisualServerHandler::close() {

+ write_buffer = PoolVector<uint8_t>::Write();

+}

+

+void SoftBodyVisualServerHandler::commit_changes() {

+ VS::get_singleton()->mesh_surface_update_region(mesh, surface, 0, buffer);

+}

+

+void SoftBodyVisualServerHandler::set_vertex(int p_vertex_id, const void *p_vector3) {

+ copymem(&write_buffer[p_vertex_id * stride + offset_vertices], p_vector3, sizeof(float) * 3);

+}

+

+void SoftBodyVisualServerHandler::set_normal(int p_vertex_id, const void *p_vector3) {

+ copymem(&write_buffer[p_vertex_id * stride + offset_normal], p_vector3, sizeof(float) * 3);

+}

+

+void SoftBodyVisualServerHandler::set_aabb(const AABB &p_aabb) {

+ VS::get_singleton()->mesh_set_custom_aabb(mesh, p_aabb);

+}

+

+SoftBody::PinnedPoint::PinnedPoint() :

+ point_index(-1),

+ spatial_attachment(NULL) {

+}

+

+SoftBody::PinnedPoint::PinnedPoint(const PinnedPoint &obj_tocopy) {

+ point_index = obj_tocopy.point_index;

+ spatial_attachment_path = obj_tocopy.spatial_attachment_path;

+ spatial_attachment = obj_tocopy.spatial_attachment;

+ offset = obj_tocopy.offset;

+}

+

+void SoftBody::_update_pickable() {

+ if (!is_inside_tree())

+ return;

+ bool pickable = ray_pickable && is_inside_tree() && is_visible_in_tree();

+ PhysicsServer::get_singleton()->soft_body_set_ray_pickable(physics_rid, pickable);

+}

+

+bool SoftBody::_set(const StringName &p_name, const Variant &p_value) {

+ String name = p_name;

+ String which = name.get_slicec('/', 0);

+

+ if ("pinned_points" == which) {

+

+ return _set_property_pinned_points_indices(p_value);

+

+ } else if ("attachments" == which) {

+

+ int idx = name.get_slicec('/', 1).to_int();

+ String what = name.get_slicec('/', 2);

+

+ return _set_property_pinned_points_attachment(idx, what, p_value);

+ }

+

+ return false;

+}

+

+bool SoftBody::_get(const StringName &p_name, Variant &r_ret) const {

+ String name = p_name;

+ String which = name.get_slicec('/', 0);

+

+ if ("pinned_points" == which) {

+ Array arr_ret;

+ const int pinned_points_indices_size = pinned_points.size();

+ PoolVector<PinnedPoint>::Read r = pinned_points.read();

+ arr_ret.resize(pinned_points_indices_size);

+

+ for (int i = 0; i < pinned_points_indices_size; ++i) {

+ arr_ret[i] = r[i].point_index;

+ }

+

+ r_ret = arr_ret;

+ return true;

+

+ } else if ("attachments" == which) {

+

+ int idx = name.get_slicec('/', 1).to_int();

+ String what = name.get_slicec('/', 2);

+

+ return _get_property_pinned_points(idx, what, r_ret);

+ }

+

+ return false;

+}

+

+void SoftBody::_get_property_list(List<PropertyInfo> *p_list) const {

+

+ const int pinned_points_indices_size = pinned_points.size();

+

+ p_list->push_back(PropertyInfo(Variant::POOL_INT_ARRAY, "pinned_points"));

+

+ for (int i = 0; i < pinned_points_indices_size; ++i) {

+ p_list->push_back(PropertyInfo(Variant::INT, "attachments/" + itos(i) + "/point_index"));

+ p_list->push_back(PropertyInfo(Variant::NODE_PATH, "attachments/" + itos(i) + "/spatial_attachment_path"));

+ p_list->push_back(PropertyInfo(Variant::VECTOR3, "attachments/" + itos(i) + "/offset"));

+ }

+}

+

+bool SoftBody::_set_property_pinned_points_indices(const Array &p_indices) {

+

+ const int p_indices_size = p_indices.size();

+

+ { // Remove the pined points on physics server that will be removed by resize

+ PoolVector<PinnedPoint>::Read r = pinned_points.read();

+ if (p_indices_size < pinned_points.size()) {

+ for (int i = pinned_points.size() - 1; i >= p_indices_size; --i) {

+ pin_point(r[i].point_index, false);

+ }

+ }

+ }

+

+ pinned_points.resize(p_indices_size);

+

+ PoolVector<PinnedPoint>::Write w = pinned_points.write();

+ int point_index;

+ for (int i = 0; i < p_indices_size; ++i) {

+ point_index = p_indices.get(i);

+ if (w[i].point_index != point_index) {

+ if (-1 != w[i].point_index)

+ pin_point(w[i].point_index, false);

+ w[i].point_index = point_index;

+ pin_point(w[i].point_index, true);

+ }

+ }

+ return true;

+}

+

+bool SoftBody::_set_property_pinned_points_attachment(int p_item, const String &p_what, const Variant &p_value) {

+ if (pinned_points.size() <= p_item) {

+ return false;

+ }

+

+ if ("spatial_attachment_path" == p_what) {

+ PoolVector<PinnedPoint>::Write w = pinned_points.write();

+ pin_point(w[p_item].point_index, true, p_value);

+ _make_cache_dirty();

+ } else if ("offset" == p_what) {

+ PoolVector<PinnedPoint>::Write w = pinned_points.write();

+ w[p_item].offset = p_value;

+ } else {

+ return false;

+ }

+

+ return true;

+}

+

+bool SoftBody::_get_property_pinned_points(int p_item, const String &p_what, Variant &r_ret) const {

+ if (pinned_points.size() <= p_item) {

+ return false;

+ }

+ PoolVector<PinnedPoint>::Read r = pinned_points.read();

+

+ if ("point_index" == p_what) {

+ r_ret = r[p_item].point_index;

+ } else if ("spatial_attachment_path" == p_what) {

+ r_ret = r[p_item].spatial_attachment_path;

+ } else if ("offset" == p_what) {

+ r_ret = r[p_item].offset;

+ } else {

+ return false;

+ }

+

+ return true;

+}

+

+void SoftBody::_changed_callback(Object *p_changed, const char *p_prop) {

+ update_physics_server();

+ _reset_points_offsets();

+#ifdef TOOLS_ENABLED

+ if (p_changed == this) {

+ update_configuration_warning();

+ }

+#endif

+}

+

+void SoftBody::_notification(int p_what) {

+ switch (p_what) {

+ case NOTIFICATION_ENTER_WORLD: {

+

+ if (Engine::get_singleton()->is_editor_hint()) {

+

+ add_change_receptor(this);

+ }

+

+ RID space = get_world()->get_space();

+ PhysicsServer::get_singleton()->soft_body_set_space(physics_rid, space);

+ update_physics_server();

+ } break;

+ case NOTIFICATION_READY: {

+ if (!parent_collision_ignore.is_empty())

+ add_collision_exception_with(get_node(parent_collision_ignore));

+

+ } break;

+ case NOTIFICATION_TRANSFORM_CHANGED: {

+

+ if (Engine::get_singleton()->is_editor_hint()) {

+ _reset_points_offsets();

+ return;

+ }

+

+ PhysicsServer::get_singleton()->soft_body_set_transform(physics_rid, get_global_transform());

+

+ set_notify_transform(false);

+ // Required to be top level with Transform at center of world in order to modify VisualServer only to support custom Transform

+ set_as_toplevel(true);

+ set_transform(Transform());

+ set_notify_transform(true);

+

+ } break;

+ case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {

+

+ if (!simulation_started)

+ return;

+

+ _update_cache_pin_points_datas();

+ // Submit bone attachment

+ const int pinned_points_indices_size = pinned_points.size();

+ PoolVector<PinnedPoint>::Read r = pinned_points.read();

+ for (int i = 0; i < pinned_points_indices_size; ++i) {

+ if (r[i].spatial_attachment) {

+ PhysicsServer::get_singleton()->soft_body_move_point(physics_rid, r[i].point_index, r[i].spatial_attachment->get_global_transform().xform(r[i].offset));

+ }

+ }

+ } break;

+ case NOTIFICATION_VISIBILITY_CHANGED: {

+

+ _update_pickable();

+

+ } break;

+ case NOTIFICATION_EXIT_WORLD: {

+

+ PhysicsServer::get_singleton()->soft_body_set_space(physics_rid, RID());

+

+ } break;

+ }

+

+#ifdef TOOLS_ENABLED

+

+ if (p_what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED) {

+ if (Engine::get_singleton()->is_editor_hint()) {

+ update_configuration_warning();

+ }

+ }

+

+#endif

+}

+

+void SoftBody::_bind_methods() {

+

+ ClassDB::bind_method(D_METHOD("_draw_soft_mesh"), &SoftBody::_draw_soft_mesh);

+

+ ClassDB::bind_method(D_METHOD("set_collision_mask", "collision_mask"), &SoftBody::set_collision_mask);

+ ClassDB::bind_method(D_METHOD("get_collision_mask"), &SoftBody::get_collision_mask);

+

+ ClassDB::bind_method(D_METHOD("set_collision_layer", "collision_layer"), &SoftBody::set_collision_layer);

+ ClassDB::bind_method(D_METHOD("get_collision_layer"), &SoftBody::get_collision_layer);

+

+ ClassDB::bind_method(D_METHOD("set_collision_mask_bit", "bit", "value"), &SoftBody::set_collision_mask_bit);

+ ClassDB::bind_method(D_METHOD("get_collision_mask_bit", "bit"), &SoftBody::get_collision_mask_bit);

+

+ ClassDB::bind_method(D_METHOD("set_collision_layer_bit", "bit", "value"), &SoftBody::set_collision_layer_bit);

+ ClassDB::bind_method(D_METHOD("get_collision_layer_bit", "bit"), &SoftBody::get_collision_layer_bit);

+

+ ClassDB::bind_method(D_METHOD("set_parent_collision_ignore", "parent_collision_ignore"), &SoftBody::set_parent_collision_ignore);

+ ClassDB::bind_method(D_METHOD("get_parent_collision_ignore"), &SoftBody::get_parent_collision_ignore);

+

+ ClassDB::bind_method(D_METHOD("add_collision_exception_with", "body"), &SoftBody::add_collision_exception_with);

+ ClassDB::bind_method(D_METHOD("remove_collision_exception_with", "body"), &SoftBody::remove_collision_exception_with);

+

+ ClassDB::bind_method(D_METHOD("set_simulation_precision", "simulation_precision"), &SoftBody::set_simulation_precision);

+ ClassDB::bind_method(D_METHOD("get_simulation_precision"), &SoftBody::get_simulation_precision);

+

+ ClassDB::bind_method(D_METHOD("set_total_mass", "mass"), &SoftBody::set_total_mass);

+ ClassDB::bind_method(D_METHOD("get_total_mass"), &SoftBody::get_total_mass);

+

+ ClassDB::bind_method(D_METHOD("set_linear_stiffness", "linear_stiffness"), &SoftBody::set_linear_stiffness);

+ ClassDB::bind_method(D_METHOD("get_linear_stiffness"), &SoftBody::get_linear_stiffness);

+

+ ClassDB::bind_method(D_METHOD("set_areaAngular_stiffness", "areaAngular_stiffness"), &SoftBody::set_areaAngular_stiffness);

+ ClassDB::bind_method(D_METHOD("get_areaAngular_stiffness"), &SoftBody::get_areaAngular_stiffness);

+

+ ClassDB::bind_method(D_METHOD("set_volume_stiffness", "volume_stiffness"), &SoftBody::set_volume_stiffness);

+ ClassDB::bind_method(D_METHOD("get_volume_stiffness"), &SoftBody::get_volume_stiffness);

+

+ ClassDB::bind_method(D_METHOD("set_pressure_coefficient", "pressure_coefficient"), &SoftBody::set_pressure_coefficient);

+ ClassDB::bind_method(D_METHOD("get_pressure_coefficient"), &SoftBody::get_pressure_coefficient);

+

+ ClassDB::bind_method(D_METHOD("set_pose_matching_coefficient", "pose_matching_coefficient"), &SoftBody::set_pose_matching_coefficient);

+ ClassDB::bind_method(D_METHOD("get_pose_matching_coefficient"), &SoftBody::get_pose_matching_coefficient);

+

+ ClassDB::bind_method(D_METHOD("set_damping_coefficient", "damping_coefficient"), &SoftBody::set_damping_coefficient);

+ ClassDB::bind_method(D_METHOD("get_damping_coefficient"), &SoftBody::get_damping_coefficient);

+

+ ClassDB::bind_method(D_METHOD("set_drag_coefficient", "drag_coefficient"), &SoftBody::set_drag_coefficient);

+ ClassDB::bind_method(D_METHOD("get_drag_coefficient"), &SoftBody::get_drag_coefficient);

+

+ ClassDB::bind_method(D_METHOD("set_ray_pickable", "ray_pickable"), &SoftBody::set_ray_pickable);

+ ClassDB::bind_method(D_METHOD("is_ray_pickable"), &SoftBody::is_ray_pickable);

+

+ ADD_GROUP("Collision", "collision_");

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");

+

+ ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "parent_collision_ignore", PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE, "Parent collision object"), "set_parent_collision_ignore", "get_parent_collision_ignore");

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "simulation_precision", PROPERTY_HINT_RANGE, "1,100,1"), "set_simulation_precision", "get_simulation_precision");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "total_mass", PROPERTY_HINT_RANGE, "0.01,10000,1"), "set_total_mass", "get_total_mass");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "linear_stiffness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_linear_stiffness", "get_linear_stiffness");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "areaAngular_stiffness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_areaAngular_stiffness", "get_areaAngular_stiffness");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "volume_stiffness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_volume_stiffness", "get_volume_stiffness");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "pressure_coefficient"), "set_pressure_coefficient", "get_pressure_coefficient");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "damping_coefficient", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_damping_coefficient", "get_damping_coefficient");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "drag_coefficient", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_drag_coefficient", "get_drag_coefficient");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "pose_matching_coefficient", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_pose_matching_coefficient", "get_pose_matching_coefficient");

+}

+

+String SoftBody::get_configuration_warning() const {

+

+ String warning = MeshInstance::get_configuration_warning();

+

+ if (get_mesh().is_null()) {

+ if (!warning.empty())

+ warning += "\n\n";

+

+ warning += TTR("This body will be ignored until you set a mesh");

+ }

+

+ Transform t = get_transform();

+ if ((ABS(t.basis.get_axis(0).length() - 1.0) > 0.05 || ABS(t.basis.get_axis(1).length() - 1.0) > 0.05 || ABS(t.basis.get_axis(0).length() - 1.0) > 0.05)) {

+ if (!warning.empty())

+ warning += "\n\n";

+

+ warning += TTR("Size changes to SoftBody will be overriden by the physics engine when running.\nChange the size in children collision shapes instead.");

+ }

+

+ return warning;

+}

+

+void SoftBody::_draw_soft_mesh() {

+ if (get_mesh().is_null())

+ return;

+

+ if (!visual_server_handler.is_ready()) {

+

+ visual_server_handler.prepare(get_mesh()->get_rid(), 0);

+

+ /// Necessary in order to render the mesh correctly (Soft body nodes are in global space)

+ simulation_started = true;

+ call_deferred("set_as_toplevel", true);

+ call_deferred("set_transform", Transform());

+ }

+

+ visual_server_handler.open();

+ PhysicsServer::get_singleton()->soft_body_update_visual_server(physics_rid, &visual_server_handler);

+ visual_server_handler.close();

+

+ visual_server_handler.commit_changes();

+}

+

+void SoftBody::update_physics_server() {

+

+ if (Engine::get_singleton()->is_editor_hint()) {

+

+ if (get_mesh().is_valid())

+ PhysicsServer::get_singleton()->soft_body_set_mesh(physics_rid, get_mesh());

+ else

+ PhysicsServer::get_singleton()->soft_body_set_mesh(physics_rid, NULL);

+

+ return;

+ }

+

+ if (get_mesh().is_valid()) {

+

+ become_mesh_owner();

+ PhysicsServer::get_singleton()->soft_body_set_mesh(physics_rid, get_mesh());

+ VS::get_singleton()->connect("frame_pre_draw", this, "_draw_soft_mesh");

+ } else {

+

+ PhysicsServer::get_singleton()->soft_body_set_mesh(physics_rid, NULL);

+ VS::get_singleton()->disconnect("frame_pre_draw", this, "_draw_soft_mesh");

+ }

+}

+

+void SoftBody::become_mesh_owner() {

+ if (mesh.is_null())

+ return;

+

+ if (!mesh_owner) {

+ mesh_owner = true;

+

+ Vector<Ref<Material> > copy_materials;

+ copy_materials.append_array(materials);

+

+ ERR_FAIL_COND(!mesh->get_surface_count());

+

+ // Get current mesh array and create new mesh array with necessary flag for softbody

+ Array surface_arrays = mesh->surface_get_arrays(0);

+ Array surface_blend_arrays = mesh->surface_get_blend_shape_arrays(0);

+ uint32_t surface_format = mesh->surface_get_format(0);

+

+ surface_format &= ~(Mesh::ARRAY_COMPRESS_VERTEX | Mesh::ARRAY_COMPRESS_NORMAL);

+ surface_format |= Mesh::ARRAY_FLAG_USE_DYNAMIC_UPDATE;

+

+ Ref<ArrayMesh> soft_mesh;

+ soft_mesh.instance();

+ soft_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, surface_arrays, surface_blend_arrays, surface_format);

+ soft_mesh->surface_set_material(0, mesh->surface_get_material(0));

+

+ set_mesh(soft_mesh);

+

+ for (int i = copy_materials.size() - 1; 0 <= i; --i) {

+ set_surface_material(i, copy_materials[i]);

+ }

+ }

+}

+

+void SoftBody::set_collision_mask(uint32_t p_mask) {

+ collision_mask = p_mask;

+ PhysicsServer::get_singleton()->soft_body_set_collision_mask(physics_rid, p_mask);

+}

+

+uint32_t SoftBody::get_collision_mask() const {

+ return collision_mask;

+}

+void SoftBody::set_collision_layer(uint32_t p_layer) {

+ collision_layer = p_layer;

+ PhysicsServer::get_singleton()->soft_body_set_collision_layer(physics_rid, p_layer);

+}

+

+uint32_t SoftBody::get_collision_layer() const {

+ return collision_layer;

+}

+

+void SoftBody::set_collision_mask_bit(int p_bit, bool p_value) {

+ uint32_t mask = get_collision_mask();

+ if (p_value)

+ mask |= 1 << p_bit;

+ else

+ mask &= ~(1 << p_bit);

+ set_collision_mask(mask);

+}

+

+bool SoftBody::get_collision_mask_bit(int p_bit) const {

+ return get_collision_mask() & (1 << p_bit);

+}

+

+void SoftBody::set_collision_layer_bit(int p_bit, bool p_value) {

+ uint32_t layer = get_collision_layer();

+ if (p_value)

+ layer |= 1 << p_bit;

+ else

+ layer &= ~(1 << p_bit);

+ set_collision_layer(layer);

+}

+

+bool SoftBody::get_collision_layer_bit(int p_bit) const {

+ return get_collision_layer() & (1 << p_bit);

+}

+

+void SoftBody::set_parent_collision_ignore(const NodePath &p_parent_collision_ignore) {

+ parent_collision_ignore = p_parent_collision_ignore;

+}

+

+const NodePath &SoftBody::get_parent_collision_ignore() const {

+ return parent_collision_ignore;

+}

+

+void SoftBody::set_pinned_points_indices(PoolVector<SoftBody::PinnedPoint> p_pinned_points_indices) {

+ pinned_points = p_pinned_points_indices;

+ PoolVector<PinnedPoint>::Read w = pinned_points.read();

+ for (int i = pinned_points.size() - 1; 0 <= i; --i) {

+ pin_point(p_pinned_points_indices[i].point_index, true);

+ }

+}

+

+PoolVector<SoftBody::PinnedPoint> SoftBody::get_pinned_points_indices() {

+ return pinned_points;

+}

+

+void SoftBody::add_collision_exception_with(Node *p_node) {

+ ERR_FAIL_NULL(p_node);

+ CollisionObject *collision_object = Object::cast_to<CollisionObject>(p_node);

+ if (!collision_object) {

+ ERR_EXPLAIN("Collision exception only works between two CollisionObject");

+ }

+ ERR_FAIL_COND(!collision_object);

+ PhysicsServer::get_singleton()->soft_body_add_collision_exception(physics_rid, collision_object->get_rid());

+}

+

+void SoftBody::remove_collision_exception_with(Node *p_node) {

+ ERR_FAIL_NULL(p_node);

+ CollisionObject *collision_object = Object::cast_to<CollisionObject>(p_node);

+ if (!collision_object) {

+ ERR_EXPLAIN("Collision exception only works between two CollisionObject");

+ }

+ ERR_FAIL_COND(!collision_object);

+ PhysicsServer::get_singleton()->soft_body_remove_collision_exception(physics_rid, collision_object->get_rid());

+}

+

+int SoftBody::get_simulation_precision() {

+ return PhysicsServer::get_singleton()->soft_body_get_simulation_precision(physics_rid);

+}

+

+void SoftBody::set_simulation_precision(int p_simulation_precision) {

+ PhysicsServer::get_singleton()->soft_body_set_simulation_precision(physics_rid, p_simulation_precision);

+}

+

+real_t SoftBody::get_total_mass() {

+ return PhysicsServer::get_singleton()->soft_body_get_total_mass(physics_rid);

+}

+

+void SoftBody::set_total_mass(real_t p_total_mass) {

+ PhysicsServer::get_singleton()->soft_body_set_total_mass(physics_rid, p_total_mass);

+}

+

+void SoftBody::set_linear_stiffness(real_t p_linear_stiffness) {

+ PhysicsServer::get_singleton()->soft_body_set_linear_stiffness(physics_rid, p_linear_stiffness);

+}

+

+real_t SoftBody::get_linear_stiffness() {

+ return PhysicsServer::get_singleton()->soft_body_get_linear_stiffness(physics_rid);

+}

+

+void SoftBody::set_areaAngular_stiffness(real_t p_areaAngular_stiffness) {

+ PhysicsServer::get_singleton()->soft_body_set_areaAngular_stiffness(physics_rid, p_areaAngular_stiffness);

+}

+

+real_t SoftBody::get_areaAngular_stiffness() {

+ return PhysicsServer::get_singleton()->soft_body_get_areaAngular_stiffness(physics_rid);

+}

+

+void SoftBody::set_volume_stiffness(real_t p_volume_stiffness) {

+ PhysicsServer::get_singleton()->soft_body_set_volume_stiffness(physics_rid, p_volume_stiffness);

+}

+

+real_t SoftBody::get_volume_stiffness() {

+ return PhysicsServer::get_singleton()->soft_body_get_volume_stiffness(physics_rid);

+}

+

+real_t SoftBody::get_pressure_coefficient() {

+ return PhysicsServer::get_singleton()->soft_body_get_pressure_coefficient(physics_rid);

+}

+

+void SoftBody::set_pose_matching_coefficient(real_t p_pose_matching_coefficient) {

+ PhysicsServer::get_singleton()->soft_body_set_pose_matching_coefficient(physics_rid, p_pose_matching_coefficient);

+}

+

+real_t SoftBody::get_pose_matching_coefficient() {

+ return PhysicsServer::get_singleton()->soft_body_get_pose_matching_coefficient(physics_rid);

+}

+

+void SoftBody::set_pressure_coefficient(real_t p_pressure_coefficient) {

+ PhysicsServer::get_singleton()->soft_body_set_pressure_coefficient(physics_rid, p_pressure_coefficient);

+}

+

+real_t SoftBody::get_damping_coefficient() {

+ return PhysicsServer::get_singleton()->soft_body_get_damping_coefficient(physics_rid);

+}

+

+void SoftBody::set_damping_coefficient(real_t p_damping_coefficient) {

+ PhysicsServer::get_singleton()->soft_body_set_damping_coefficient(physics_rid, p_damping_coefficient);

+}

+

+real_t SoftBody::get_drag_coefficient() {

+ return PhysicsServer::get_singleton()->soft_body_get_drag_coefficient(physics_rid);

+}

+

+void SoftBody::set_drag_coefficient(real_t p_drag_coefficient) {

+ PhysicsServer::get_singleton()->soft_body_set_drag_coefficient(physics_rid, p_drag_coefficient);

+}

+

+Vector3 SoftBody::get_point_transform(int p_point_index) {

+ return PhysicsServer::get_singleton()->soft_body_get_point_global_position(physics_rid, p_point_index);

+}

+

+void SoftBody::pin_point_toggle(int p_point_index) {

+ pin_point(p_point_index, !(-1 != _has_pinned_point(p_point_index)));

+}

+

+void SoftBody::pin_point(int p_point_index, bool pin, const NodePath &p_spatial_attachment_path) {

+ _pin_point_on_physics_server(p_point_index, pin);

+ if (pin) {

+ _add_pinned_point(p_point_index, p_spatial_attachment_path);

+ } else {

+ _remove_pinned_point(p_point_index);

+ }

+}

+

+bool SoftBody::is_point_pinned(int p_point_index) const {

+ return -1 != _has_pinned_point(p_point_index);

+}

+

+void SoftBody::set_ray_pickable(bool p_ray_pickable) {

+

+ ray_pickable = p_ray_pickable;

+ _update_pickable();

+}

+

+bool SoftBody::is_ray_pickable() const {

+

+ return ray_pickable;

+}

+

+SoftBody::SoftBody() :

+ MeshInstance(),

+ physics_rid(PhysicsServer::get_singleton()->soft_body_create()),

+ mesh_owner(false),

+ collision_mask(1),

+ collision_layer(1),

+ simulation_started(false),

+ pinned_points_cache_dirty(true) {

+

+ PhysicsServer::get_singleton()->body_attach_object_instance_id(physics_rid, get_instance_id());

+ //set_notify_transform(true);

+ set_physics_process_internal(true);

+}

+

+SoftBody::~SoftBody() {

+}

+

+void SoftBody::reset_softbody_pin() {

+ PhysicsServer::get_singleton()->soft_body_remove_all_pinned_points(physics_rid);

+ PoolVector<PinnedPoint>::Read pps = pinned_points.read();

+ for (int i = pinned_points.size() - 1; 0 < i; --i) {

+ PhysicsServer::get_singleton()->soft_body_pin_point(physics_rid, pps[i].point_index, true);

+ }

+}

+

+void SoftBody::_make_cache_dirty() {

+ pinned_points_cache_dirty = true;

+}

+

+void SoftBody::_update_cache_pin_points_datas() {

+ if (!pinned_points_cache_dirty)

+ return;

+

+ pinned_points_cache_dirty = false;

+

+ PoolVector<PinnedPoint>::Write w = pinned_points.write();

+ for (int i = pinned_points.size() - 1; 0 <= i; --i) {

+

+ if (!w[i].spatial_attachment_path.is_empty()) {

+ w[i].spatial_attachment = Object::cast_to<Spatial>(get_node(w[i].spatial_attachment_path));

+ }

+ if (!w[i].spatial_attachment) {

+ ERR_PRINT("Spatial node not defined in the pinned point, Softbody undefined behaviour!");

+ }

+ }

+}

+

+void SoftBody::_pin_point_on_physics_server(int p_point_index, bool pin) {

+ PhysicsServer::get_singleton()->soft_body_pin_point(physics_rid, p_point_index, pin);

+}

+

+void SoftBody::_add_pinned_point(int p_point_index, const NodePath &p_spatial_attachment_path) {

+ SoftBody::PinnedPoint *pinned_point;

+ if (-1 == _get_pinned_point(p_point_index, pinned_point)) {

+

+ // Create new

+ PinnedPoint pp;

+ pp.point_index = p_point_index;

+ pp.spatial_attachment_path = p_spatial_attachment_path;

+

+ if (!p_spatial_attachment_path.is_empty() && has_node(p_spatial_attachment_path)) {

+ pp.spatial_attachment = Object::cast_to<Spatial>(get_node(p_spatial_attachment_path));

+ pp.offset = (pp.spatial_attachment->get_global_transform().affine_inverse() * get_global_transform()).xform(PhysicsServer::get_singleton()->soft_body_get_point_global_position(physics_rid, pp.point_index));

+ }

+

+ pinned_points.push_back(pp);

+

+ } else {

+

+ pinned_point->point_index = p_point_index;

+ pinned_point->spatial_attachment_path = p_spatial_attachment_path;

+

+ if (!p_spatial_attachment_path.is_empty() && has_node(p_spatial_attachment_path)) {

+ pinned_point->spatial_attachment = Object::cast_to<Spatial>(get_node(p_spatial_attachment_path));

+ pinned_point->offset = (pinned_point->spatial_attachment->get_global_transform().affine_inverse() * get_global_transform()).xform(PhysicsServer::get_singleton()->soft_body_get_point_global_position(physics_rid, pinned_point->point_index));

+ }

+ }

+}

+

+void SoftBody::_reset_points_offsets() {

+

+ if (!Engine::get_singleton()->is_editor_hint())

+ return;

+

+ PoolVector<PinnedPoint>::Read r = pinned_points.read();

+ PoolVector<PinnedPoint>::Write w = pinned_points.write();

+ for (int i = pinned_points.size() - 1; 0 <= i; --i) {

+

+ if (!r[i].spatial_attachment)

+ w[i].spatial_attachment = Object::cast_to<Spatial>(get_node(r[i].spatial_attachment_path));

+

+ if (!r[i].spatial_attachment)

+ continue;

+

+ w[i].offset = (r[i].spatial_attachment->get_global_transform().affine_inverse() * get_global_transform()).xform(PhysicsServer::get_singleton()->soft_body_get_point_global_position(physics_rid, r[i].point_index));

+ }

+}

+

+void SoftBody::_remove_pinned_point(int p_point_index) {

+ const int id(_has_pinned_point(p_point_index));

+ if (-1 != id) {

+ pinned_points.remove(id);

+ }

+}

+

+int SoftBody::_get_pinned_point(int p_point_index, SoftBody::PinnedPoint *&r_point) const {

+ const int id = _has_pinned_point(p_point_index);

+ if (-1 == id) {

+ r_point = NULL;

+ return -1;

+ } else {

+ r_point = const_cast<SoftBody::PinnedPoint *>(&pinned_points.read()[id]);

+ return id;

+ }

+}

+

+int SoftBody::_has_pinned_point(int p_point_index) const {

+ PoolVector<PinnedPoint>::Read r = pinned_points.read();

+ for (int i = pinned_points.size() - 1; 0 <= i; --i) {

+ if (p_point_index == r[i].point_index) {

+ return i;

+ }

+ }

+ return -1;

+}

+/*************************************************************************/

+/* soft_physics_body.h */

+/* Author: AndreaCatania */

+/*************************************************************************/

+/* This file is part of: */

+/* GODOT ENGINE */

+/* http://www.godotengine.org */

+/*************************************************************************/

+/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */

+/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */

+/* */

+/* 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 SOFT_PHYSICS_BODY_H

+#define SOFT_PHYSICS_BODY_H

+

+#include "scene/3d/mesh_instance.h"

+

+class SoftBody;

+

+class SoftBodyVisualServerHandler {

+

+ friend class SoftBody;

+

+ RID mesh;

+ int surface;

+ PoolVector<uint8_t> buffer;

+ uint32_t stride;

+ uint32_t offset_vertices;

+ uint32_t offset_normal;

+

+ PoolVector<uint8_t>::Write write_buffer;

+

+private:

+ SoftBodyVisualServerHandler();

+ bool is_ready() { return mesh.is_valid(); }

+ void prepare(RID p_mesh_rid, int p_surface);

+ void clear();

+ void open();

+ void close();

+ void commit_changes();

+

+public:

+ void set_vertex(int p_vertex_id, const void *p_vector3);

+ void set_normal(int p_vertex_id, const void *p_vector3);

+ void set_aabb(const AABB &p_aabb);

+};

+

+class SoftBody : public MeshInstance {

+ GDCLASS(SoftBody, MeshInstance);

+

+public:

+ struct PinnedPoint {

+ int point_index;

+ NodePath spatial_attachment_path;

+ Spatial *spatial_attachment; // Cache

+ Vector3 offset;

+

+ PinnedPoint();

+ PinnedPoint(const PinnedPoint &obj_tocopy);

+ };

+

+private:

+ SoftBodyVisualServerHandler visual_server_handler;

+

+ RID physics_rid;

+

+ bool mesh_owner;

+ uint32_t collision_mask;

+ uint32_t collision_layer;

+ NodePath parent_collision_ignore;

+ PoolVector<PinnedPoint> pinned_points;

+ bool simulation_started;

+ bool pinned_points_cache_dirty;

+

+ Ref<ArrayMesh> debug_mesh_cache;

+ class MeshInstance *debug_mesh;

+

+ bool capture_input_on_drag;

+ bool ray_pickable;

+

+ void _update_pickable();

+

+protected:

+ bool _set(const StringName &p_name, const Variant &p_value);

+ bool _get(const StringName &p_name, Variant &r_ret) const;

+ void _get_property_list(List<PropertyInfo> *p_list) const;

+

+ bool _set_property_pinned_points_indices(const Array &p_indices);

+ bool _set_property_pinned_points_attachment(int p_item, const String &p_what, const Variant &p_value);

+ bool _get_property_pinned_points(int p_item, const String &p_what, Variant &r_ret) const;

+

+ virtual void _changed_callback(Object *p_changed, const char *p_prop);

+

+ void _notification(int p_what);

+ static void _bind_methods();

+

+ virtual String get_configuration_warning() const;

+

+protected:

+ void _draw_soft_mesh();

+

+public:

+ void update_physics_server();

+ void become_mesh_owner();

+

+ void set_collision_mask(uint32_t p_mask);

+ uint32_t get_collision_mask() const;

+

+ void set_collision_layer(uint32_t p_layer);

+ uint32_t get_collision_layer() const;

+

+ void set_collision_mask_bit(int p_bit, bool p_value);

+ bool get_collision_mask_bit(int p_bit) const;

+

+ void set_collision_layer_bit(int p_bit, bool p_value);

+ bool get_collision_layer_bit(int p_bit) const;

+

+ void set_parent_collision_ignore(const NodePath &p_parent_collision_ignore);

+ const NodePath &get_parent_collision_ignore() const;

+

+ void set_pinned_points_indices(PoolVector<PinnedPoint> p_pinned_points_indices);

+ PoolVector<PinnedPoint> get_pinned_points_indices();

+

+ void set_simulation_precision(int p_simulation_precision);

+ int get_simulation_precision();

+

+ void set_total_mass(real_t p_total_mass);

+ real_t get_total_mass();

+

+ void set_linear_stiffness(real_t p_linear_stiffness);

+ real_t get_linear_stiffness();

+

+ void set_areaAngular_stiffness(real_t p_areaAngular_stiffness);

+ real_t get_areaAngular_stiffness();

+

+ void set_volume_stiffness(real_t p_volume_stiffness);

+ real_t get_volume_stiffness();

+

+ void set_pressure_coefficient(real_t p_pressure_coefficient);

+ real_t get_pressure_coefficient();

+

+ void set_pose_matching_coefficient(real_t p_pose_matching_coefficient);

+ real_t get_pose_matching_coefficient();

+

+ void set_damping_coefficient(real_t p_damping_coefficient);

+ real_t get_damping_coefficient();

+

+ void set_drag_coefficient(real_t p_drag_coefficient);

+ real_t get_drag_coefficient();

+

+ void add_collision_exception_with(Node *p_node);

+ void remove_collision_exception_with(Node *p_node);

+

+ Vector3 get_point_transform(int p_point_index);

+

+ void pin_point_toggle(int p_point_index);

+ void pin_point(int p_point_index, bool pin, const NodePath &p_spatial_attachment_path = NodePath());

+ bool is_point_pinned(int p_point_index) const;

+

+ void set_ray_pickable(bool p_ray_pickable);

+ bool is_ray_pickable() const;

+

+ SoftBody();

+ ~SoftBody();

+

+private:

+ void reset_softbody_pin();

+

+ void _make_cache_dirty();

+ void _update_cache_pin_points_datas();

+

+ void _pin_point_on_physics_server(int p_point_index, bool pin);

+ void _add_pinned_point(int p_point_index, const NodePath &p_spatial_attachment_path);

+ void _reset_points_offsets();

+

+ void _remove_pinned_point(int p_point_index);

+ int _get_pinned_point(int p_point_index, PinnedPoint *&r_point) const;

+ int _has_pinned_point(int p_point_index) const;

+};

+

+#endif // SOFT_PHYSICS_BODY_H

+ data.gizmo.unref();

+ if (data.disable_scale) {

+ data.global_transform.basis.orthonormalize();

+ }

+

+void Spatial::set_disable_scale(bool p_enabled) {

+

+ data.disable_scale = p_enabled;

+}

+

+bool Spatial::is_scale_disabled() const {

+ return data.disable_scale;

+}

+

+ t.basis.rotate(p_axis, p_angle);

+ t.basis.scale(p_scale);

+ ClassDB::bind_method(D_METHOD("set_disable_scale", "disable"), &Spatial::set_disable_scale);

+ ClassDB::bind_method(D_METHOD("is_scale_disabled"), &Spatial::is_scale_disabled);

+ ADD_GROUP("Matrix", "");

+ ADD_PROPERTYNZ(PropertyInfo(Variant::TRANSFORM, "transform", PROPERTY_HINT_NONE, ""), "set_transform", "get_transform");

+ data.disable_scale = false;

+ virtual ~SpatialGizmo() {}

+ bool disable_scale;

+ void set_disable_scale(bool p_enabled);

+ bool is_scale_disabled() const;

+

+ position_history.write[i] = position_history[i - 1];

+ position_history.write[0] = ph;

+ position_history.write[0] = ph;

+/*************************************************************************/

+/* spring_arm.cpp */

+/*************************************************************************/

+/* This file is part of: */

+/* GODOT ENGINE */

+/* https://godotengine.org */

+/*************************************************************************/

+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */

+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */

+/* */

+/* 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. */

+/*************************************************************************/

+

+#include "spring_arm.h"

+#include "engine.h"

+#include "scene/3d/collision_object.h"

+#include "scene/resources/sphere_shape.h"

+#include "servers/physics_server.h"

+

+SpringArm::SpringArm() :

+ spring_length(1),

+ mask(1),

+ current_spring_length(0),

+ margin(0.01) {}

+

+void SpringArm::_notification(int p_what) {

+ switch (p_what) {

+ case NOTIFICATION_ENTER_TREE:

+ if (!Engine::get_singleton()->is_editor_hint()) {

+ set_process_internal(true);

+ }

+ break;

+ case NOTIFICATION_EXIT_TREE:

+ if (!Engine::get_singleton()->is_editor_hint()) {

+ set_process_internal(false);

+ }

+ break;

+ case NOTIFICATION_INTERNAL_PROCESS:

+ process_spring();

+ break;

+ }

+}

+

+void SpringArm::_bind_methods() {

+

+ ClassDB::bind_method(D_METHOD("get_hit_length"), &SpringArm::get_hit_length);

+

+ ClassDB::bind_method(D_METHOD("set_length", "length"), &SpringArm::set_length);

+ ClassDB::bind_method(D_METHOD("get_length"), &SpringArm::get_length);

+

+ ClassDB::bind_method(D_METHOD("set_shape", "shape"), &SpringArm::set_shape);

+ ClassDB::bind_method(D_METHOD("get_shape"), &SpringArm::get_shape);

+

+ ClassDB::bind_method(D_METHOD("add_excluded_object", "RID"), &SpringArm::add_excluded_object);

+ ClassDB::bind_method(D_METHOD("remove_excluded_object", "RID"), &SpringArm::remove_excluded_object);

+ ClassDB::bind_method(D_METHOD("clear_excluded_objects"), &SpringArm::clear_excluded_objects);

+

+ ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &SpringArm::set_mask);

+ ClassDB::bind_method(D_METHOD("get_collision_mask"), &SpringArm::get_mask);

+

+ ClassDB::bind_method(D_METHOD("set_margin", "margin"), &SpringArm::set_margin);

+ ClassDB::bind_method(D_METHOD("get_margin"), &SpringArm::get_margin);

+

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");

+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape"), "set_shape", "get_shape");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "spring_length"), "set_length", "get_length");

+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "margin"), "set_margin", "get_margin");

+}

+

+float SpringArm::get_length() const {

+ return spring_length;

+}

+

+void SpringArm::set_length(float p_length) {

+ if (is_inside_tree() && (Engine::get_singleton()->is_editor_hint() || get_tree()->is_debugging_collisions_hint()))

+ update_gizmo();

+

+ spring_length = p_length;

+}

+

+void SpringArm::set_shape(Ref<Shape> p_shape) {

+ shape = p_shape;

+}

+

+Ref<Shape> SpringArm::get_shape() const {

+ return shape;

+}

+

+void SpringArm::set_mask(uint32_t p_mask) {

+ mask = p_mask;

+}

+

+uint32_t SpringArm::get_mask() {

+ return mask;

+}

+

+float SpringArm::get_margin() {

+ return margin;

+}

+

+void SpringArm::set_margin(float p_margin) {

+ margin = p_margin;

+}

+

+void SpringArm::add_excluded_object(RID p_rid) {

+ excluded_objects.insert(p_rid);

+}

+

+bool SpringArm::remove_excluded_object(RID p_rid) {

+ return excluded_objects.erase(p_rid);

+}

+

+void SpringArm::clear_excluded_objects() {

+ excluded_objects.clear();

+}

+

+float SpringArm::get_hit_length() {

+ return current_spring_length;

+}

+

+void SpringArm::process_spring() {

+ // From

+ real_t motion_delta(1);

+ real_t motion_delta_unsafe(1);

+

+ Vector3 motion;

+ const Vector3 cast_direction(get_global_transform().basis.xform(Vector3(0, 0, 1)));

+

+ if (shape.is_null()) {

+ motion = Vector3(cast_direction * (spring_length));

+ PhysicsDirectSpaceState::RayResult r;

+ bool intersected = get_world()->get_direct_space_state()->intersect_ray(get_global_transform().origin, get_global_transform().origin + motion, r, excluded_objects, mask);

+ if (intersected) {

+ float dist = get_global_transform().origin.distance_to(r.position);

+ dist -= margin;

+ motion_delta = dist / (spring_length);

+ }

+ } else {

+ motion = Vector3(cast_direction * spring_length);

+ get_world()->get_direct_space_state()->cast_motion(shape->get_rid(), get_global_transform(), motion, 0, motion_delta, motion_delta_unsafe, excluded_objects, mask);

+ }

+

+ current_spring_length = spring_length * motion_delta;

+ Transform childs_transform;

+ childs_transform.origin = get_global_transform().origin + cast_direction * (spring_length * motion_delta);

+

+ for (int i = get_child_count() - 1; 0 <= i; --i) {

+

+ Spatial *child = Object::cast_to<Spatial>(get_child(i));

+ if (child) {

+ childs_transform.basis = child->get_global_transform().basis;

+ child->set_global_transform(childs_transform);

+ }

+ }

+}

+/*************************************************************************/

+/* spring_arm.h */

+/*************************************************************************/

+/* This file is part of: */

+/* GODOT ENGINE */

+/* https://godotengine.org */

+/*************************************************************************/

+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */

+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */

+/* */

+/* 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 SPRING_ARM_H

+#define SPRING_ARM_H

+

+#include "scene/3d/spatial.h"

+

+class SpringArm : public Spatial {

+ GDCLASS(SpringArm, Spatial);

+

+ Ref<Shape> shape;

+ Set<RID> excluded_objects;

+ float spring_length;

+ bool keep_child_basis;

+ float current_spring_length;

+ uint32_t mask;

+ float margin;

+

+protected:

+ void _notification(int p_what);

+ static void _bind_methods();

+

+public:

+ void set_length(float p_length);

+ float get_length() const;

+ void set_shape(Ref<Shape> p_shape);

+ Ref<Shape> get_shape() const;

+ void set_mask(uint32_t p_mask);

+ uint32_t get_mask();

+ void add_excluded_object(RID p_rid);

+ bool remove_excluded_object(RID p_rid);

+ void clear_excluded_objects();

+ float get_hit_length();

+ void set_margin(float p_margin);

+ float get_margin();

+

+ SpringArm();

+

+private:

+ void process_spring();

+};

+

+#endif

+ PhysicsBody *body2, const Vector3 &pos2, const Vector3 &normal, real_t &impulse, const real_t p_rollInfluence) {

+ m_sideImpulse.write[i] = real_t(0.);

+ m_forwardImpulse.write[i] = real_t(0.);

+ m_axle.write[i] = wheelBasis0.get_axis(Vector3::AXIS_X);

+ m_axle.write[i] -= surfNormalWS * proj;

+ m_axle.write[i] = m_axle[i].normalized();

+ m_forwardWS.write[i] = surfNormalWS.cross(m_axle[i]);

+ m_forwardWS.write[i].normalize();

+ m_axle[i], m_sideImpulse.write[i], wheelInfo.m_rollInfluence);

+ m_sideImpulse.write[i] *= sideFrictionStiffness2;

+ m_forwardImpulse.write[wheel] = real_t(0.);

+ m_forwardImpulse.write[wheel] = rollingFriction; //wheelInfo.m_engineForce* timeStep;

+ m_forwardImpulse.write[wheel] *= wheels[wheel]->m_skidInfo;

+ m_sideImpulse.write[wheel] *= wheels[wheel]->m_skidInfo;

+ void _resolve_single_bilateral(PhysicsDirectBodyState *s, const Vector3 &pos1, PhysicsBody *body2, const Vector3 &pos2, const Vector3 &normal, real_t &impulse, const real_t p_rollInfluence);

+void VisualInstance::set_layer_mask_bit(int p_layer, bool p_enable) {

+ ERR_FAIL_INDEX(p_layer, 32);

+ if (p_enable) {

+ set_layer_mask(layers | (1 << p_layer));

+ } else {

+ set_layer_mask(layers & (~(1 << p_layer)));

+ }

+}

+

+bool VisualInstance::get_layer_mask_bit(int p_layer) const {

+ ERR_FAIL_INDEX_V(p_layer, 32, false);

+ return (layers & (1 << p_layer));

+}

+

+ ClassDB::bind_method(D_METHOD("set_layer_mask_bit", "layer", "enabled"), &VisualInstance::set_layer_mask_bit);

+ ClassDB::bind_method(D_METHOD("get_layer_mask_bit", "layer"), &VisualInstance::get_layer_mask_bit);

+ void set_layer_mask_bit(int p_layer, bool p_enable);

+ bool get_layer_mask_bit(int p_layer) const;

+

+/*======================== Z-tests ========================*/

+ bake_cells.write[p_idx].albedo[0] += albedo_accum.r;

+ bake_cells.write[p_idx].albedo[1] += albedo_accum.g;

+ bake_cells.write[p_idx].albedo[2] += albedo_accum.b;

+ bake_cells.write[p_idx].emission[0] += emission_accum.r;

+ bake_cells.write[p_idx].emission[1] += emission_accum.g;

+ bake_cells.write[p_idx].emission[2] += emission_accum.b;

+ bake_cells.write[p_idx].normal[0] += normal_accum.x;

+ bake_cells.write[p_idx].normal[1] += normal_accum.y;

+ bake_cells.write[p_idx].normal[2] += normal_accum.z;

+ bake_cells.write[p_idx].alpha += alpha;

+ bake_cells.write[p_idx].children[i] = child_idx;

+ bake_cells.write[child_idx].level = p_level + 1;

+ ret.write[i] = p_color_add;

+ ret.write[i] = c;

+ bake_light.write[p_idx].x = p_x;

+ bake_light.write[p_idx].y = p_y;

+ bake_light.write[p_idx].z = p_z;

+ bake_light.write[p_idx].next_leaf = first_leaf;

+ bake_cells.write[p_idx].albedo[0] /= alpha;

+ bake_cells.write[p_idx].albedo[1] /= alpha;

+ bake_cells.write[p_idx].albedo[2] /= alpha;

+ bake_cells.write[p_idx].emission[0] /= alpha;

+ bake_cells.write[p_idx].emission[1] /= alpha;

+ bake_cells.write[p_idx].emission[2] /= alpha;

+ bake_cells.write[p_idx].normal[0] /= alpha;

+ bake_cells.write[p_idx].normal[1] /= alpha;

+ bake_cells.write[p_idx].normal[2] /= alpha;

+ bake_cells.write[p_idx].normal[0] = 0;

+ bake_cells.write[p_idx].normal[1] = 0;

+ bake_cells.write[p_idx].normal[2] = 0;

+ bake_cells.write[p_idx].normal[0] = n.x;

+ bake_cells.write[p_idx].normal[1] = n.y;

+ bake_cells.write[p_idx].normal[2] = n.z;

+ bake_cells.write[p_idx].alpha = 1.0;

+ bake_cells.write[p_idx].emission[0] = 0;

+ bake_cells.write[p_idx].emission[1] = 0;

+ bake_cells.write[p_idx].emission[2] = 0;

+ bake_cells.write[p_idx].normal[0] = 0;

+ bake_cells.write[p_idx].normal[1] = 0;

+ bake_cells.write[p_idx].normal[2] = 0;

+ bake_cells.write[p_idx].albedo[0] = 0;

+ bake_cells.write[p_idx].albedo[1] = 0;

+ bake_cells.write[p_idx].albedo[2] = 0;

+ bake_light.write[p_idx].accum[j][0] = 0;

+ bake_light.write[p_idx].accum[j][1] = 0;

+ bake_light.write[p_idx].accum[j][2] = 0;

+ bake_light.write[p_idx].accum[j][0] += bake_light[child].accum[j][0];

+ bake_light.write[p_idx].accum[j][1] += bake_light[child].accum[j][1];

+ bake_light.write[p_idx].accum[j][2] += bake_light[child].accum[j][2];

+ bake_cells.write[p_idx].emission[0] += bake_cells[child].emission[0];

+ bake_cells.write[p_idx].emission[1] += bake_cells[child].emission[1];

+ bake_cells.write[p_idx].emission[2] += bake_cells[child].emission[2];

+ bake_cells.write[p_idx].alpha = alpha_average / 8.0;

+ bake_light.write[p_idx].accum[j][0] /= divisor;

+ bake_light.write[p_idx].accum[j][1] /= divisor;

+ bake_light.write[p_idx].accum[j][2] /= divisor;

+ bake_cells.write[p_idx].emission[0] /= divisor;

+ bake_cells.write[p_idx].emission[1] /= divisor;

+ bake_cells.write[p_idx].emission[2] /= divisor;

+ //print_line("bake line " + itos(i) + " / " + itos(height));

+ remap.write[i] = c;

+ octree.write[i].alpha = bake_cells[demap[i]].alpha;

+ octree.write[i].light[j][k] = CLAMP(l * 1024, 0, 65535); //give two more bits to octree

+ octree.write[i].children[j] = child == CHILD_EMPTY ? CHILD_EMPTY : remap[child];