godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/scene/3d/body_shape.cpp

921 lines
25 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* body_shape.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
Welcome in 2017, dear changelog reader! That year should bring the long-awaited OpenGL ES 3.0 compatible renderer with state-of-the-art rendering techniques tuned to work as low as middle end handheld devices - without compromising with the possibilities given for higher end desktop games of course. Great times ahead for the Godot community and the gamers that will play our games!
2017-01-01 21:01:57 +00:00
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
Add "Godot Engine contributors" copyright line
2017-04-07 22:11:42 +00:00
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "body_shape.h"
#include "scene/resources/box_shape.h"
#include "scene/resources/capsule_shape.h"
#include "scene/resources/concave_polygon_shape.h"
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#include "scene/resources/convex_polygon_shape.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "scene/resources/plane_shape.h"
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#include "scene/resources/ray_shape.h"
#include "scene/resources/sphere_shape.h"
#include "servers/visual_server.h"
Drop empty files that are not used anywhere Part of #5272
2016-06-18 17:46:30 +00:00
//TODO: Implement CylinderShape and HeightMapShape?
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "mesh_instance.h"
#include "physics_body.h"
#include "quick_hull.h"
void CollisionShape::_update_body() {
Ability to visually debug geometry visually: -Visible 2D and 3D Shapes, Polygons, Tile collisions, etc. -Visible Navmesh and Navpoly -Visible collision contacts for 2D and 3D as a red point -Customizable colors in project settings
2015-09-20 16:03:46 +00:00
if (!is_inside_tree() || !can_update_body)
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
return;
if (!get_tree()->is_editor_hint())
return;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (get_parent() && get_parent()->cast_to<CollisionObject>())
get_parent()->cast_to<CollisionObject>()->_update_shapes_from_children();
}
void CollisionShape::make_convex_from_brothers() {
Node *p = get_parent();
if (!p)
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < p->get_child_count(); i++) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Node *n = p->get_child(i);
if (n->cast_to<MeshInstance>()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
MeshInstance *mi = n->cast_to<MeshInstance>();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Ref<Mesh> m = mi->get_mesh();
if (m.is_valid()) {
Ref<Shape> s = m->create_convex_shape();
set_shape(s);
}
}
}
}
Bug Fixes -=-=-=-=- -Fixed problem with scaling shapes (#827), related to not taking scale in consideration for calculating the moment of inertia -Added support for multiline strings (or comments) using """ -Save subscene bug, properties not being saved in root node (#806) -Fix Crash in CollisionPolygon2DEditor (#814) -Restored Ability to compile without 3D (#795) -Fix InterpolatedCamera (#803) -Fix UV Import for OBJ Meshes (#771) -Fixed issue with modifier gizmos (#794) -Fixed CapsuleShape gizmo handle (#50) -Fixed Import Button (not properly working in 3D) (#733) -Many misc fixes (though no new features)
2014-11-02 14:31:01 +00:00
/*
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void CollisionShape::_update_indicator() {
while (VisualServer::get_singleton()->mesh_get_surface_count(indicator))
VisualServer::get_singleton()->mesh_remove_surface(indicator,0);
if (shape.is_null())
return;
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
VS::PrimitiveType pt = VS::PRIMITIVE_TRIANGLES;
if (shape->cast_to<RayShape>()) {
RayShape *rs = shape->cast_to<RayShape>();
points.push_back(Vector3());
points.push_back(Vector3(0,0,rs->get_length()));
pt = VS::PRIMITIVE_LINES;
} else if (shape->cast_to<SphereShape>()) {
Style: Fix whole-line commented code They do not play well with clang-format which aligns the `//` part with the rest of the code block, thus producing badly indented commented code.
2017-01-14 11:26:56 +00:00
//VisualServer *vs=VisualServer::get_singleton();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
SphereShape *shapeptr=shape->cast_to<SphereShape>();
Color col(0.4,1.0,1.0,0.5);
int lats=6;
int lons=12;
float size=shapeptr->get_radius();
for(int i = 1; i <= lats; i++) {
double lat0 = Math_PI * (-0.5 + (double) (i - 1) / lats);
double z0 = Math::sin(lat0);
double zr0 = Math::cos(lat0);
double lat1 = Math_PI * (-0.5 + (double) i / lats);
double z1 = Math::sin(lat1);
double zr1 = Math::cos(lat1);
for(int j = lons; j >= 1; j--) {
double lng0 = 2 * Math_PI * (double) (j - 1) / lons;
double x0 = Math::cos(lng0);
double y0 = Math::sin(lng0);
double lng1 = 2 * Math_PI * (double) (j) / lons;
double x1 = Math::cos(lng1);
double y1 = Math::sin(lng1);
Vector3 v4=Vector3(x0 * zr0, z0, y0 *zr0)*size;
Vector3 v3=Vector3(x0 * zr1, z1, y0 *zr1)*size;
Vector3 v2=Vector3(x1 * zr1, z1, y1 *zr1)*size;
Vector3 v1=Vector3(x1 * zr0, z0, y1 *zr0)*size;
Vector<Vector3> line;
line.push_back(v1);
line.push_back(v2);
line.push_back(v3);
line.push_back(v4);
points.push_back(v1);
points.push_back(v2);
points.push_back(v3);
points.push_back(v1);
points.push_back(v3);
points.push_back(v4);
normals.push_back(v1.normalized());
normals.push_back(v2.normalized());
normals.push_back(v3.normalized());
normals.push_back(v1.normalized());
normals.push_back(v3.normalized());
normals.push_back(v4.normalized());
}
}
} else if (shape->cast_to<BoxShape>()) {
BoxShape *shapeptr=shape->cast_to<BoxShape>();
for (int i=0;i<6;i++) {
Vector3 face_points[4];
for (int j=0;j<4;j++) {
float v[3];
v[0]=1.0;
v[1]=1-2*((j>>1)&1);
v[2]=v[1]*(1-2*(j&1));
for (int k=0;k<3;k++) {
if (i<3)
face_points[j][(i+k)%3]=v[k]*(i>=3?-1:1);
else
face_points[3-j][(i+k)%3]=v[k]*(i>=3?-1:1);
}
}
Vector3 normal;
normal[i%3]=(i>=3?-1:1);
for(int j=0;j<4;j++)
face_points[j]*=shapeptr->get_extents();
points.push_back(face_points[0]);
points.push_back(face_points[1]);
points.push_back(face_points[2]);
points.push_back(face_points[0]);
points.push_back(face_points[2]);
points.push_back(face_points[3]);
for(int n=0;n<6;n++)
normals.push_back(normal);
}
} else if (shape->cast_to<ConvexPolygonShape>()) {
ConvexPolygonShape *shapeptr=shape->cast_to<ConvexPolygonShape>();
Geometry::MeshData md;
QuickHull::build(Variant(shapeptr->get_points()),md);
for(int i=0;i<md.faces.size();i++) {
for(int j=2;j<md.faces[i].indices.size();j++) {
points.push_back(md.vertices[md.faces[i].indices[0]]);
points.push_back(md.vertices[md.faces[i].indices[j-1]]);
points.push_back(md.vertices[md.faces[i].indices[j]]);
normals.push_back(md.faces[i].plane.normal);
normals.push_back(md.faces[i].plane.normal);
normals.push_back(md.faces[i].plane.normal);
}
}
} else if (shape->cast_to<ConcavePolygonShape>()) {
ConcavePolygonShape *shapeptr=shape->cast_to<ConcavePolygonShape>();
points = shapeptr->get_faces();
for(int i=0;i<points.size()/3;i++) {
Vector3 n = Plane( points[i*3+0],points[i*3+1],points[i*3+2] ).normal;
normals.push_back(n);
normals.push_back(n);
normals.push_back(n);
}
} else if (shape->cast_to<CapsuleShape>()) {
CapsuleShape *shapeptr=shape->cast_to<CapsuleShape>();
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Plane> planes = Geometry::build_capsule_planes(shapeptr->get_radius(), shapeptr->get_height()/2.0, 12, Vector3::AXIS_Z);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Geometry::MeshData md = Geometry::build_convex_mesh(planes);
for(int i=0;i<md.faces.size();i++) {
for(int j=2;j<md.faces[i].indices.size();j++) {
points.push_back(md.vertices[md.faces[i].indices[0]]);
points.push_back(md.vertices[md.faces[i].indices[j-1]]);
points.push_back(md.vertices[md.faces[i].indices[j]]);
normals.push_back(md.faces[i].plane.normal);
normals.push_back(md.faces[i].plane.normal);
normals.push_back(md.faces[i].plane.normal);
}
}
} else if (shape->cast_to<PlaneShape>()) {
PlaneShape *shapeptr=shape->cast_to<PlaneShape>();
Plane p = shapeptr->get_plane();
Vector3 n1 = p.get_any_perpendicular_normal();
Vector3 n2 = p.normal.cross(n1).normalized();
Vector3 pface[4]={
p.normal*p.d+n1*100.0+n2*100.0,
p.normal*p.d+n1*100.0+n2*-100.0,
p.normal*p.d+n1*-100.0+n2*-100.0,
p.normal*p.d+n1*-100.0+n2*100.0,
};
points.push_back(pface[0]);
points.push_back(pface[1]);
points.push_back(pface[2]);
points.push_back(pface[0]);
points.push_back(pface[2]);
points.push_back(pface[3]);
normals.push_back(p.normal);
normals.push_back(p.normal);
normals.push_back(p.normal);
normals.push_back(p.normal);
normals.push_back(p.normal);
normals.push_back(p.normal);
}
if (!points.size())
return;
RID material = VisualServer::get_singleton()->fixed_material_create();
VisualServer::get_singleton()->fixed_material_set_param(material,VS::FIXED_MATERIAL_PARAM_DIFFUSE,Color(0,0.6,0.7,0.3));
VisualServer::get_singleton()->fixed_material_set_param(material,VS::FIXED_MATERIAL_PARAM_EMISSION,0.7);
if (normals.size()==0)
VisualServer::get_singleton()->material_set_flag(material,VS::MATERIAL_FLAG_UNSHADED,true);
VisualServer::get_singleton()->material_set_flag(material,VS::MATERIAL_FLAG_DOUBLE_SIDED,true);
Array d;
d.resize(VS::ARRAY_MAX);
d[VS::ARRAY_VERTEX]=points;
if (normals.size())
d[VS::ARRAY_NORMAL]=normals;
VisualServer::get_singleton()->mesh_add_surface(indicator,pt,d);
VisualServer::get_singleton()->mesh_surface_set_material(indicator,0,material,true);
}
Bug Fixes -=-=-=-=- -Fixed problem with scaling shapes (#827), related to not taking scale in consideration for calculating the moment of inertia -Added support for multiline strings (or comments) using """ -Save subscene bug, properties not being saved in root node (#806) -Fix Crash in CollisionPolygon2DEditor (#814) -Restored Ability to compile without 3D (#795) -Fix InterpolatedCamera (#803) -Fix UV Import for OBJ Meshes (#771) -Fixed issue with modifier gizmos (#794) -Fixed CapsuleShape gizmo handle (#50) -Fixed Import Button (not properly working in 3D) (#733) -Many misc fixes (though no new features)
2014-11-02 14:31:01 +00:00
*/
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void CollisionShape::_add_to_collision_object(Object *p_cshape) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Bug Fixes -=-=-=-=- -Fixed problem with scaling shapes (#827), related to not taking scale in consideration for calculating the moment of inertia -Added support for multiline strings (or comments) using """ -Save subscene bug, properties not being saved in root node (#806) -Fix Crash in CollisionPolygon2DEditor (#814) -Restored Ability to compile without 3D (#795) -Fix InterpolatedCamera (#803) -Fix UV Import for OBJ Meshes (#771) -Fixed issue with modifier gizmos (#794) -Fixed CapsuleShape gizmo handle (#50) -Fixed Import Button (not properly working in 3D) (#733) -Many misc fixes (though no new features)
2014-11-02 14:31:01 +00:00
if (unparenting)
return;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
CollisionObject *co = p_cshape->cast_to<CollisionObject>();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND(!co);
if (shape.is_valid()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
update_shape_index = co->get_shape_count();
co->add_shape(shape, get_transform());
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
if (trigger)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
co->set_shape_as_trigger(co->get_shape_count() - 1, true);
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
update_shape_index = -1;
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
void CollisionShape::_notification(int p_what) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (p_what) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 00:20:42 +00:00
case NOTIFICATION_ENTER_TREE: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
unparenting = false;
can_update_body = get_tree()->is_editor_hint();
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
set_notify_local_transform(!can_update_body);
Bug Fixes -=-=-=-=- -Fixed problem with scaling shapes (#827), related to not taking scale in consideration for calculating the moment of inertia -Added support for multiline strings (or comments) using """ -Save subscene bug, properties not being saved in root node (#806) -Fix Crash in CollisionPolygon2DEditor (#814) -Restored Ability to compile without 3D (#795) -Fix InterpolatedCamera (#803) -Fix UV Import for OBJ Meshes (#771) -Fixed issue with modifier gizmos (#794) -Fixed CapsuleShape gizmo handle (#50) -Fixed Import Button (not properly working in 3D) (#733) -Many misc fixes (though no new features)
2014-11-02 14:31:01 +00:00
Ability to visually debug geometry visually: -Visible 2D and 3D Shapes, Polygons, Tile collisions, etc. -Visible Navmesh and Navpoly -Visible collision contacts for 2D and 3D as a red point -Customizable colors in project settings
2015-09-20 16:03:46 +00:00
if (get_tree()->is_debugging_collisions_hint()) {
_create_debug_shape();
}
Bug Fixes -=-=-=-=- -Fixed problem with scaling shapes (#827), related to not taking scale in consideration for calculating the moment of inertia -Added support for multiline strings (or comments) using """ -Save subscene bug, properties not being saved in root node (#806) -Fix Crash in CollisionPolygon2DEditor (#814) -Restored Ability to compile without 3D (#795) -Fix InterpolatedCamera (#803) -Fix UV Import for OBJ Meshes (#771) -Fixed issue with modifier gizmos (#794) -Fixed CapsuleShape gizmo handle (#50) -Fixed Import Button (not properly working in 3D) (#733) -Many misc fixes (though no new features)
2014-11-02 14:31:01 +00:00
//indicator_instance = VisualServer::get_singleton()->instance_create2(indicator,get_world()->get_scenario());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
case NOTIFICATION_TRANSFORM_CHANGED: {
Style: Fix whole-line commented code They do not play well with clang-format which aligns the `//` part with the rest of the code block, thus producing badly indented commented code.
2017-01-14 11:26:56 +00:00
//VisualServer::get_singleton()->instance_set_transform(indicator_instance,get_global_transform());
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
if (can_update_body && updating_body) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
_update_body();
}
} break;
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 00:20:42 +00:00
case NOTIFICATION_EXIT_TREE: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
/* if (indicator_instance.is_valid()) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
VisualServer::get_singleton()->free(indicator_instance);
indicator_instance=RID();
Bug Fixes -=-=-=-=- -Fixed problem with scaling shapes (#827), related to not taking scale in consideration for calculating the moment of inertia -Added support for multiline strings (or comments) using """ -Save subscene bug, properties not being saved in root node (#806) -Fix Crash in CollisionPolygon2DEditor (#814) -Restored Ability to compile without 3D (#795) -Fix InterpolatedCamera (#803) -Fix UV Import for OBJ Meshes (#771) -Fixed issue with modifier gizmos (#794) -Fixed CapsuleShape gizmo handle (#50) -Fixed Import Button (not properly working in 3D) (#733) -Many misc fixes (though no new features)
2014-11-02 14:31:01 +00:00
}*/
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
can_update_body = false;
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
set_notify_local_transform(false);
Ability to visually debug geometry visually: -Visible 2D and 3D Shapes, Polygons, Tile collisions, etc. -Visible Navmesh and Navpoly -Visible collision contacts for 2D and 3D as a red point -Customizable colors in project settings
2015-09-20 16:03:46 +00:00
if (debug_shape) {
debug_shape->queue_delete();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
debug_shape = NULL;
Ability to visually debug geometry visually: -Visible 2D and 3D Shapes, Polygons, Tile collisions, etc. -Visible Navmesh and Navpoly -Visible collision contacts for 2D and 3D as a red point -Customizable colors in project settings
2015-09-20 16:03:46 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
case NOTIFICATION_UNPARENTED: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
unparenting = true;
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
if (can_update_body && updating_body)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
_update_body();
} break;
case NOTIFICATION_PARENTED: {
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
if (can_update_body && updating_body)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
_update_body();
} break;
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (!can_update_body && update_shape_index >= 0) {
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
CollisionObject *co = get_parent()->cast_to<CollisionObject>();
if (co) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
co->set_shape_transform(update_shape_index, get_transform());
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
}
}
} break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
void CollisionShape::resource_changed(RES res) {
update_gizmo();
}
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
void CollisionShape::_set_update_shape_index(int p_index) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
update_shape_index = p_index;
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int CollisionShape::_get_update_shape_index() const {
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
return update_shape_index;
}
-Added configuration warning system for nodes -Added a new "add" and "instance" buttons for scene tree -Added a vformat() function to ease translation work
2016-05-17 21:27:15 +00:00
String CollisionShape::get_configuration_warning() const {
if (!get_parent()->cast_to<CollisionObject>()) {
return TTR("CollisionShape only serves to provide a collision shape to a CollisionObject derived node. Please only use it as a child of Area, StaticBody, RigidBody, KinematicBody, etc. to give them a shape.");
}
if (!shape.is_valid()) {
return TTR("A shape must be provided for CollisionShape to function. Please create a shape resource for it!");
}
return String();
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void CollisionShape::_bind_methods() {
//not sure if this should do anything
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ClassDB::bind_method(D_METHOD("resource_changed", "resource"), &CollisionShape::resource_changed);
ClassDB::bind_method(D_METHOD("set_shape", "shape"), &CollisionShape::set_shape);
ClassDB::bind_method(D_METHOD("get_shape"), &CollisionShape::get_shape);
ClassDB::bind_method(D_METHOD("_add_to_collision_object"), &CollisionShape::_add_to_collision_object);
ClassDB::bind_method(D_METHOD("set_trigger", "enable"), &CollisionShape::set_trigger);
ClassDB::bind_method(D_METHOD("is_trigger"), &CollisionShape::is_trigger);
ClassDB::bind_method(D_METHOD("make_convex_from_brothers"), &CollisionShape::make_convex_from_brothers);
ClassDB::set_method_flags("CollisionShape", "make_convex_from_brothers", METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
ClassDB::bind_method(D_METHOD("_set_update_shape_index", "index"), &CollisionShape::_set_update_shape_index);
ClassDB::bind_method(D_METHOD("_get_update_shape_index"), &CollisionShape::_get_update_shape_index);
ClassDB::bind_method(D_METHOD("get_collision_object_shape_index"), &CollisionShape::get_collision_object_shape_index);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape"), "set_shape", "get_shape");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "trigger"), "set_trigger", "is_trigger");
ADD_PROPERTY(PropertyInfo(Variant::INT, "_update_shape_index", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_update_shape_index", "_get_update_shape_index");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
void CollisionShape::set_shape(const Ref<Shape> &p_shape) {
if (!shape.is_null())
shape->unregister_owner(this);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
shape = p_shape;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (!shape.is_null())
shape->register_owner(this);
update_gizmo();
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
if (updating_body) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
_update_body();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (can_update_body && update_shape_index >= 0 && is_inside_tree()) {
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
CollisionObject *co = get_parent()->cast_to<CollisionObject>();
if (co) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
co->set_shape(update_shape_index, p_shape);
Ability to keep collisionshapes and collisionpolygons when running the game. Works for 2D and 3D These are still just helpers in case you want to animate them or access them directly. Modifying the real shapes is still done via CollisionObject and CollisionObject2D APIs But an API was added so you can query which shapes from CollisionObject correspond to which CollisionShape. Have Fun!
2015-09-16 01:07:03 +00:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Ref<Shape> CollisionShape::get_shape() const {
return shape;
}
void CollisionShape::set_updating_body(bool p_update) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
updating_body = p_update;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
bool CollisionShape::is_updating_body() const {
return updating_body;
}
void CollisionShape::set_trigger(bool p_trigger) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
trigger = p_trigger;
if (updating_body) {
_update_body();
} else if (can_update_body && update_shape_index >= 0 && is_inside_tree()) {
CollisionObject *co = get_parent()->cast_to<CollisionObject>();
if (co) {
co->set_shape_as_trigger(update_shape_index, p_trigger);
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool CollisionShape::is_trigger() const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return trigger;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
CollisionShape::CollisionShape() {
Bug Fixes -=-=-=-=- -Fixed problem with scaling shapes (#827), related to not taking scale in consideration for calculating the moment of inertia -Added support for multiline strings (or comments) using """ -Save subscene bug, properties not being saved in root node (#806) -Fix Crash in CollisionPolygon2DEditor (#814) -Restored Ability to compile without 3D (#795) -Fix InterpolatedCamera (#803) -Fix UV Import for OBJ Meshes (#771) -Fixed issue with modifier gizmos (#794) -Fixed CapsuleShape gizmo handle (#50) -Fixed Import Button (not properly working in 3D) (#733) -Many misc fixes (though no new features)
2014-11-02 14:31:01 +00:00
//indicator = VisualServer::get_singleton()->mesh_create();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
updating_body = true;
unparenting = false;
update_shape_index = -1;
trigger = false;
can_update_body = false;
debug_shape = NULL;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
CollisionShape::~CollisionShape() {
if (!shape.is_null())
shape->unregister_owner(this);
Bug Fixes -=-=-=-=- -Fixed problem with scaling shapes (#827), related to not taking scale in consideration for calculating the moment of inertia -Added support for multiline strings (or comments) using """ -Save subscene bug, properties not being saved in root node (#806) -Fix Crash in CollisionPolygon2DEditor (#814) -Restored Ability to compile without 3D (#795) -Fix InterpolatedCamera (#803) -Fix UV Import for OBJ Meshes (#771) -Fixed issue with modifier gizmos (#794) -Fixed CapsuleShape gizmo handle (#50) -Fixed Import Button (not properly working in 3D) (#733) -Many misc fixes (though no new features)
2014-11-02 14:31:01 +00:00
//VisualServer::get_singleton()->free(indicator);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Ability to visually debug geometry visually: -Visible 2D and 3D Shapes, Polygons, Tile collisions, etc. -Visible Navmesh and Navpoly -Visible collision contacts for 2D and 3D as a red point -Customizable colors in project settings
2015-09-20 16:03:46 +00:00
void CollisionShape::_create_debug_shape() {
if (debug_shape) {
Style: Fix statements ending with ';;'
2017-01-14 17:03:38 +00:00
debug_shape->queue_delete();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
debug_shape = NULL;
Ability to visually debug geometry visually: -Visible 2D and 3D Shapes, Polygons, Tile collisions, etc. -Visible Navmesh and Navpoly -Visible collision contacts for 2D and 3D as a red point -Customizable colors in project settings
2015-09-20 16:03:46 +00:00
}
Ref<Shape> s = get_shape();
if (s.is_null())
return;
Ref<Mesh> mesh = s->get_debug_mesh();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
MeshInstance *mi = memnew(MeshInstance);
Ability to visually debug geometry visually: -Visible 2D and 3D Shapes, Polygons, Tile collisions, etc. -Visible Navmesh and Navpoly -Visible collision contacts for 2D and 3D as a red point -Customizable colors in project settings
2015-09-20 16:03:46 +00:00
mi->set_mesh(mesh);
add_child(mi);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
debug_shape = mi;
Ability to visually debug geometry visually: -Visible 2D and 3D Shapes, Polygons, Tile collisions, etc. -Visible Navmesh and Navpoly -Visible collision contacts for 2D and 3D as a red point -Customizable colors in project settings
2015-09-20 16:03:46 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#if 0
#include "body_volume.h"
#include "geometry.h"
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#include "scene/3d/physics_body.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#define ADD_TRIANGLE(m_a, m_b, m_c, m_color) \
{ \
Vector<Vector3> points; \
points.resize(3); \
points[0] = m_a; \
points[1] = m_b; \
points[2] = m_c; \
Vector<Color> colors; \
colors.resize(3); \
colors[0] = m_color; \
colors[1] = m_color; \
colors[2] = m_color; \
vs->poly_add_primitive(p_indicator, points, Vector<Vector3>(), colors, Vector<Vector3>()); \
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void CollisionShape::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_SCENE: {
if (get_root_node()->get_editor() && !indicator.is_valid()) {
indicator=VisualServer::get_singleton()->poly_create();
RID mat=VisualServer::get_singleton()->fixed_material_create();
VisualServer::get_singleton()->material_set_flag( mat, VisualServer::MATERIAL_FLAG_UNSHADED, true );
VisualServer::get_singleton()->material_set_flag( mat, VisualServer::MATERIAL_FLAG_WIREFRAME, true );
VisualServer::get_singleton()->material_set_flag( mat, VisualServer::MATERIAL_FLAG_DOUBLE_SIDED, true );
VisualServer::get_singleton()->material_set_line_width( mat, 3 );
VisualServer::get_singleton()->poly_set_material(indicator,mat,true);
update_indicator(indicator);
}
if (indicator.is_valid()) {
indicator_instance=VisualServer::get_singleton()->instance_create2(indicator,get_world()->get_scenario());
VisualServer::get_singleton()->instance_attach_object_instance_ID(indicator_instance,get_instance_ID());
}
volume_changed();
} break;
case NOTIFICATION_EXIT_SCENE: {
if (indicator_instance.is_valid()) {
VisualServer::get_singleton()->free(indicator_instance);
}
volume_changed();
} break;
case NOTIFICATION_TRANSFORM_CHANGED: {
if (indicator_instance.is_valid()) {
VisualServer::get_singleton()->instance_set_transform(indicator_instance,get_global_transform());
}
volume_changed();
} break;
default: {}
}
}
void CollisionShape::volume_changed() {
if (indicator.is_valid())
update_indicator(indicator);
Object *parent=get_parent();
if (!parent)
return;
PhysicsBody *physics_body=parent->cast_to<PhysicsBody>();
ERR_EXPLAIN("CollisionShape parent is not of type PhysicsBody");
ERR_FAIL_COND(!physics_body);
physics_body->recompute_child_volumes();
}
RID CollisionShape::_get_visual_instance_rid() const {
return indicator_instance;
}
void CollisionShape::_bind_methods() {
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 02:03:46 +00:00
ClassDB::bind_method("_get_visual_instance_rid",&CollisionShape::_get_visual_instance_rid);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
CollisionShape::CollisionShape() {
}
CollisionShape::~CollisionShape() {
if (indicator.is_valid()) {
VisualServer::get_singleton()->free(indicator);
}
}
void CollisionShapeSphere::_set(const String& p_name, const Variant& p_value) {
if (p_name=="radius") {
radius=p_value;
volume_changed();
}
}
Variant CollisionShapeSphere::_get(const String& p_name) const {
if (p_name=="radius") {
return radius;
}
return Variant();
}
void CollisionShapeSphere::_get_property_list( List<PropertyInfo> *p_list) const {
p_list->push_back( PropertyInfo(Variant::REAL,"radius",PROPERTY_HINT_RANGE,"0.01,16384,0.01") );
}
void CollisionShapeSphere::update_indicator(RID p_indicator) {
VisualServer *vs=VisualServer::get_singleton();
vs->poly_clear(p_indicator);
Color col(0.4,1.0,1.0,0.5);
int lats=6;
int lons=12;
float size=radius;
for(int i = 1; i <= lats; i++) {
double lat0 = Math_PI * (-0.5 + (double) (i - 1) / lats);
double z0 = Math::sin(lat0);
double zr0 = Math::cos(lat0);
double lat1 = Math_PI * (-0.5 + (double) i / lats);
double z1 = Math::sin(lat1);
double zr1 = Math::cos(lat1);
for(int j = lons; j >= 1; j--) {
double lng0 = 2 * Math_PI * (double) (j - 1) / lons;
double x0 = Math::cos(lng0);
double y0 = Math::sin(lng0);
double lng1 = 2 * Math_PI * (double) (j) / lons;
double x1 = Math::cos(lng1);
double y1 = Math::sin(lng1);
Vector3 v4=Vector3(x0 * zr0, z0, y0 *zr0)*size;
Vector3 v3=Vector3(x0 * zr1, z1, y0 *zr1)*size;
Vector3 v2=Vector3(x1 * zr1, z1, y1 *zr1)*size;
Vector3 v1=Vector3(x1 * zr0, z0, y1 *zr0)*size;
Vector<Vector3> line;
line.push_back(v1);
line.push_back(v2);
line.push_back(v3);
line.push_back(v4);
Vector<Color> cols;
cols.push_back(col);
cols.push_back(col);
cols.push_back(col);
cols.push_back(col);
VisualServer::get_singleton()->poly_add_primitive(p_indicator,line,Vector<Vector3>(),cols,Vector<Vector3>());
}
}
}
void CollisionShapeSphere::append_to_volume(Ref<Shape> p_volume) {
p_volume->add_sphere_shape(radius,get_transform());
}
CollisionShapeSphere::CollisionShapeSphere() {
radius=1.0;
}
/* BOX */
void CollisionShapeBox::_set(const String& p_name, const Variant& p_value) {
if (p_name=="half_extents") {
half_extents=p_value;
volume_changed();
}
}
Variant CollisionShapeBox::_get(const String& p_name) const {
if (p_name=="half_extents") {
return half_extents;
}
return Variant();
}
void CollisionShapeBox::_get_property_list( List<PropertyInfo> *p_list) const {
p_list->push_back( PropertyInfo(Variant::VECTOR3,"half_extents" ) );
}
void CollisionShapeBox::update_indicator(RID p_indicator) {
VisualServer *vs=VisualServer::get_singleton();
vs->poly_clear(p_indicator);
Color col(0.4,1.0,1.0,0.5);
for (int i=0;i<6;i++) {
Vector3 face_points[4];
for (int j=0;j<4;j++) {
float v[3];
v[0]=1.0;
v[1]=1-2*((j>>1)&1);
v[2]=v[1]*(1-2*(j&1));
for (int k=0;k<3;k++) {
if (i<3)
face_points[j][(i+k)%3]=v[k]*(i>=3?-1:1);
else
face_points[3-j][(i+k)%3]=v[k]*(i>=3?-1:1);
}
}
for(int j=0;j<4;j++)
face_points[i]*=half_extents;
ADD_TRIANGLE(face_points[0],face_points[1],face_points[2],col);
ADD_TRIANGLE(face_points[2],face_points[3],face_points[0],col);
}
}
void CollisionShapeBox::append_to_volume(Ref<Shape> p_volume) {
p_volume->add_box_shape(half_extents,get_transform());
}
CollisionShapeBox::CollisionShapeBox() {
half_extents=Vector3(1,1,1);
}
/* CYLINDER */
void CollisionShapeCylinder::_set(const String& p_name, const Variant& p_value) {
if (p_name=="radius") {
radius=p_value;
volume_changed();
}
if (p_name=="height") {
height=p_value;
volume_changed();
}
}
Variant CollisionShapeCylinder::_get(const String& p_name) const {
if (p_name=="radius") {
return radius;
}
if (p_name=="height") {
return height;
}
return Variant();
}
void CollisionShapeCylinder::_get_property_list( List<PropertyInfo> *p_list) const {
p_list->push_back( PropertyInfo(Variant::REAL,"radius",PROPERTY_HINT_RANGE,"0.01,16384,0.01") );
p_list->push_back( PropertyInfo(Variant::REAL,"height",PROPERTY_HINT_RANGE,"0.01,16384,0.01") );
}
void CollisionShapeCylinder::update_indicator(RID p_indicator) {
VisualServer *vs=VisualServer::get_singleton();
vs->poly_clear(p_indicator);
Color col(0.4,1.0,1.0,0.5);
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Plane> planes = Geometry::build_cylinder_planes(radius, height, 12, Vector3::AXIS_Z);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Geometry::MeshData md = Geometry::build_convex_mesh(planes);
for(int i=0;i<md.faces.size();i++) {
for(int j=2;j<md.faces[i].indices.size();j++) {
ADD_TRIANGLE(md.vertices[md.faces[i].indices[0]],md.vertices[md.faces[i].indices[j-1]],md.vertices[md.faces[i].indices[j]],col);
}
}
}
void CollisionShapeCylinder::append_to_volume(Ref<Shape> p_volume) {
p_volume->add_cylinder_shape(radius,height*2.0,get_transform());
}
CollisionShapeCylinder::CollisionShapeCylinder() {
height=1;
radius=1;
}
/* CAPSULE */
void CollisionShapeCapsule::_set(const String& p_name, const Variant& p_value) {
if (p_name=="radius") {
radius=p_value;
volume_changed();
}
if (p_name=="height") {
height=p_value;
volume_changed();
}
}
Variant CollisionShapeCapsule::_get(const String& p_name) const {
if (p_name=="radius") {
return radius;
}
if (p_name=="height") {
return height;
}
return Variant();
}
void CollisionShapeCapsule::_get_property_list( List<PropertyInfo> *p_list) const {
p_list->push_back( PropertyInfo(Variant::REAL,"radius",PROPERTY_HINT_RANGE,"0.01,16384,0.01") );
p_list->push_back( PropertyInfo(Variant::REAL,"height",PROPERTY_HINT_RANGE,"0.01,16384,0.01") );
}
void CollisionShapeCapsule::update_indicator(RID p_indicator) {
VisualServer *vs=VisualServer::get_singleton();
vs->poly_clear(p_indicator);
Color col(0.4,1.0,1.0,0.5);
Memory pool vectors (DVector) have been enormously simplified in code, and renamed to PoolVector
2017-01-07 21:25:37 +00:00
PoolVector<Plane> planes = Geometry::build_capsule_planes(radius, height, 12, 3, Vector3::AXIS_Z);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Geometry::MeshData md = Geometry::build_convex_mesh(planes);
for(int i=0;i<md.faces.size();i++) {
for(int j=2;j<md.faces[i].indices.size();j++) {
ADD_TRIANGLE(md.vertices[md.faces[i].indices[0]],md.vertices[md.faces[i].indices[j-1]],md.vertices[md.faces[i].indices[j]],col);
}
}
}
void CollisionShapeCapsule::append_to_volume(Ref<Shape> p_volume) {
p_volume->add_capsule_shape(radius,height,get_transform());
}
CollisionShapeCapsule::CollisionShapeCapsule() {
height=1;
radius=1;
}
#endif