mirror of
https://github.com/godotengine/godot.git
synced 2024-12-21 10:25:24 +08:00
bfa246cda8
OmniLight and SpotLight gizmos were tweaked to better represent their depth in the 3D world. The default light gizmo color was changed to match the gizmo icon color closely.
4590 lines
132 KiB
C++
4590 lines
132 KiB
C++
/*************************************************************************/
|
|
/* spatial_editor_gizmos.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2019 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 "spatial_editor_gizmos.h"
|
|
|
|
#include "core/math/geometry.h"
|
|
#include "core/math/quick_hull.h"
|
|
#include "scene/3d/audio_stream_player_3d.h"
|
|
#include "scene/3d/baked_lightmap.h"
|
|
#include "scene/3d/collision_polygon.h"
|
|
#include "scene/3d/collision_shape.h"
|
|
#include "scene/3d/cpu_particles.h"
|
|
#include "scene/3d/gi_probe.h"
|
|
#include "scene/3d/light.h"
|
|
#include "scene/3d/listener.h"
|
|
#include "scene/3d/mesh_instance.h"
|
|
#include "scene/3d/navigation_mesh.h"
|
|
#include "scene/3d/particles.h"
|
|
#include "scene/3d/physics_joint.h"
|
|
#include "scene/3d/portal.h"
|
|
#include "scene/3d/position_3d.h"
|
|
#include "scene/3d/ray_cast.h"
|
|
#include "scene/3d/reflection_probe.h"
|
|
#include "scene/3d/room_instance.h"
|
|
#include "scene/3d/soft_body.h"
|
|
#include "scene/3d/spring_arm.h"
|
|
#include "scene/3d/sprite_3d.h"
|
|
#include "scene/3d/vehicle_body.h"
|
|
#include "scene/3d/visibility_notifier.h"
|
|
#include "scene/resources/box_shape.h"
|
|
#include "scene/resources/capsule_shape.h"
|
|
#include "scene/resources/concave_polygon_shape.h"
|
|
#include "scene/resources/convex_polygon_shape.h"
|
|
#include "scene/resources/cylinder_shape.h"
|
|
#include "scene/resources/height_map_shape.h"
|
|
#include "scene/resources/plane_shape.h"
|
|
#include "scene/resources/primitive_meshes.h"
|
|
#include "scene/resources/ray_shape.h"
|
|
#include "scene/resources/sphere_shape.h"
|
|
#include "scene/resources/surface_tool.h"
|
|
|
|
#define HANDLE_HALF_SIZE 9.5
|
|
|
|
bool EditorSpatialGizmo::is_editable() const {
|
|
|
|
ERR_FAIL_COND_V(!spatial_node, false);
|
|
Node *edited_root = spatial_node->get_tree()->get_edited_scene_root();
|
|
if (spatial_node == edited_root)
|
|
return true;
|
|
if (spatial_node->get_owner() == edited_root)
|
|
return true;
|
|
|
|
if (edited_root->is_editable_instance(spatial_node->get_owner()))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void EditorSpatialGizmo::clear() {
|
|
|
|
for (int i = 0; i < instances.size(); i++) {
|
|
|
|
if (instances[i].instance.is_valid())
|
|
VS::get_singleton()->free(instances[i].instance);
|
|
}
|
|
|
|
billboard_handle = false;
|
|
collision_segments.clear();
|
|
collision_mesh = Ref<TriangleMesh>();
|
|
instances.clear();
|
|
handles.clear();
|
|
secondary_handles.clear();
|
|
}
|
|
|
|
void EditorSpatialGizmo::redraw() {
|
|
|
|
if (get_script_instance() && get_script_instance()->has_method("redraw")) {
|
|
get_script_instance()->call("redraw");
|
|
return;
|
|
}
|
|
|
|
ERR_FAIL_COND(!gizmo_plugin);
|
|
gizmo_plugin->redraw(this);
|
|
}
|
|
|
|
String EditorSpatialGizmo::get_handle_name(int p_idx) const {
|
|
|
|
if (get_script_instance() && get_script_instance()->has_method("get_handle_name")) {
|
|
return get_script_instance()->call("get_handle_name", p_idx);
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!gizmo_plugin, "");
|
|
return gizmo_plugin->get_handle_name(this, p_idx);
|
|
}
|
|
|
|
bool EditorSpatialGizmo::is_handle_highlighted(int p_idx) const {
|
|
|
|
if (get_script_instance() && get_script_instance()->has_method("is_handle_highlighted")) {
|
|
return get_script_instance()->call("is_handle_highlighted", p_idx);
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!gizmo_plugin, false);
|
|
return gizmo_plugin->is_handle_highlighted(this, p_idx);
|
|
}
|
|
|
|
Variant EditorSpatialGizmo::get_handle_value(int p_idx) {
|
|
|
|
if (get_script_instance() && get_script_instance()->has_method("get_handle_value")) {
|
|
return get_script_instance()->call("get_handle_value", p_idx);
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!gizmo_plugin, Variant());
|
|
return gizmo_plugin->get_handle_value(this, p_idx);
|
|
}
|
|
|
|
void EditorSpatialGizmo::set_handle(int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
if (get_script_instance() && get_script_instance()->has_method("set_handle")) {
|
|
get_script_instance()->call("set_handle", p_idx, p_camera, p_point);
|
|
return;
|
|
}
|
|
|
|
ERR_FAIL_COND(!gizmo_plugin);
|
|
gizmo_plugin->set_handle(this, p_idx, p_camera, p_point);
|
|
}
|
|
|
|
void EditorSpatialGizmo::commit_handle(int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
if (get_script_instance() && get_script_instance()->has_method("commit_handle")) {
|
|
get_script_instance()->call("commit_handle", p_idx, p_restore, p_cancel);
|
|
return;
|
|
}
|
|
|
|
ERR_FAIL_COND(!gizmo_plugin);
|
|
gizmo_plugin->commit_handle(this, p_idx, p_restore, p_cancel);
|
|
}
|
|
|
|
void EditorSpatialGizmo::set_spatial_node(Spatial *p_node) {
|
|
|
|
ERR_FAIL_NULL(p_node);
|
|
spatial_node = p_node;
|
|
}
|
|
|
|
void EditorSpatialGizmo::Instance::create_instance(Spatial *p_base, bool p_hidden) {
|
|
|
|
instance = VS::get_singleton()->instance_create2(mesh->get_rid(), p_base->get_world()->get_scenario());
|
|
VS::get_singleton()->instance_attach_object_instance_id(instance, p_base->get_instance_id());
|
|
if (skeleton.is_valid())
|
|
VS::get_singleton()->instance_attach_skeleton(instance, skeleton);
|
|
if (extra_margin)
|
|
VS::get_singleton()->instance_set_extra_visibility_margin(instance, 1);
|
|
VS::get_singleton()->instance_geometry_set_cast_shadows_setting(instance, VS::SHADOW_CASTING_SETTING_OFF);
|
|
int layer = p_hidden ? 0 : 1 << SpatialEditorViewport::GIZMO_EDIT_LAYER;
|
|
VS::get_singleton()->instance_set_layer_mask(instance, layer); //gizmos are 26
|
|
}
|
|
|
|
void EditorSpatialGizmo::add_mesh(const Ref<ArrayMesh> &p_mesh, bool p_billboard, const RID &p_skeleton, const Ref<Material> &p_material) {
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
Instance ins;
|
|
|
|
ins.billboard = p_billboard;
|
|
ins.mesh = p_mesh;
|
|
ins.skeleton = p_skeleton;
|
|
ins.material = p_material;
|
|
if (valid) {
|
|
ins.create_instance(spatial_node, hidden);
|
|
VS::get_singleton()->instance_set_transform(ins.instance, spatial_node->get_global_transform());
|
|
if (ins.material.is_valid()) {
|
|
VS::get_singleton()->instance_geometry_set_material_override(ins.instance, p_material->get_rid());
|
|
}
|
|
}
|
|
|
|
instances.push_back(ins);
|
|
}
|
|
|
|
void EditorSpatialGizmo::add_lines(const Vector<Vector3> &p_lines, const Ref<Material> &p_material, bool p_billboard) {
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
Instance ins;
|
|
|
|
Ref<ArrayMesh> mesh = memnew(ArrayMesh);
|
|
Array a;
|
|
a.resize(Mesh::ARRAY_MAX);
|
|
|
|
a[Mesh::ARRAY_VERTEX] = p_lines;
|
|
|
|
PoolVector<Color> color;
|
|
color.resize(p_lines.size());
|
|
{
|
|
PoolVector<Color>::Write w = color.write();
|
|
for (int i = 0; i < p_lines.size(); i++) {
|
|
if (is_selected())
|
|
w[i] = Color(1, 1, 1, 0.8);
|
|
else
|
|
w[i] = Color(1, 1, 1, 0.2);
|
|
}
|
|
}
|
|
|
|
a[Mesh::ARRAY_COLOR] = color;
|
|
|
|
mesh->add_surface_from_arrays(Mesh::PRIMITIVE_LINES, a);
|
|
mesh->surface_set_material(0, p_material);
|
|
|
|
if (p_billboard) {
|
|
float md = 0;
|
|
for (int i = 0; i < p_lines.size(); i++) {
|
|
|
|
md = MAX(0, p_lines[i].length());
|
|
}
|
|
if (md) {
|
|
mesh->set_custom_aabb(AABB(Vector3(-md, -md, -md), Vector3(md, md, md) * 2.0));
|
|
}
|
|
}
|
|
|
|
ins.billboard = p_billboard;
|
|
ins.mesh = mesh;
|
|
if (valid) {
|
|
ins.create_instance(spatial_node, hidden);
|
|
VS::get_singleton()->instance_set_transform(ins.instance, spatial_node->get_global_transform());
|
|
}
|
|
|
|
instances.push_back(ins);
|
|
}
|
|
|
|
void EditorSpatialGizmo::add_unscaled_billboard(const Ref<Material> &p_material, float p_scale) {
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
Instance ins;
|
|
|
|
Vector<Vector3> vs;
|
|
Vector<Vector2> uv;
|
|
|
|
vs.push_back(Vector3(-p_scale, p_scale, 0));
|
|
vs.push_back(Vector3(p_scale, p_scale, 0));
|
|
vs.push_back(Vector3(p_scale, -p_scale, 0));
|
|
vs.push_back(Vector3(-p_scale, -p_scale, 0));
|
|
|
|
uv.push_back(Vector2(0, 0));
|
|
uv.push_back(Vector2(1, 0));
|
|
uv.push_back(Vector2(1, 1));
|
|
uv.push_back(Vector2(0, 1));
|
|
|
|
Ref<ArrayMesh> mesh = memnew(ArrayMesh);
|
|
Array a;
|
|
a.resize(Mesh::ARRAY_MAX);
|
|
a[Mesh::ARRAY_VERTEX] = vs;
|
|
a[Mesh::ARRAY_TEX_UV] = uv;
|
|
mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLE_FAN, a);
|
|
mesh->surface_set_material(0, p_material);
|
|
|
|
float md = 0;
|
|
for (int i = 0; i < vs.size(); i++) {
|
|
|
|
md = MAX(0, vs[i].length());
|
|
}
|
|
if (md) {
|
|
mesh->set_custom_aabb(AABB(Vector3(-md, -md, -md), Vector3(md, md, md) * 2.0));
|
|
}
|
|
|
|
selectable_icon_size = p_scale;
|
|
mesh->set_custom_aabb(AABB(Vector3(-selectable_icon_size, -selectable_icon_size, -selectable_icon_size) * 100.0f, Vector3(selectable_icon_size, selectable_icon_size, selectable_icon_size) * 200.0f));
|
|
|
|
ins.mesh = mesh;
|
|
ins.unscaled = true;
|
|
ins.billboard = true;
|
|
if (valid) {
|
|
ins.create_instance(spatial_node, hidden);
|
|
VS::get_singleton()->instance_set_transform(ins.instance, spatial_node->get_global_transform());
|
|
}
|
|
|
|
selectable_icon_size = p_scale;
|
|
|
|
instances.push_back(ins);
|
|
}
|
|
|
|
void EditorSpatialGizmo::add_collision_triangles(const Ref<TriangleMesh> &p_tmesh) {
|
|
collision_mesh = p_tmesh;
|
|
}
|
|
|
|
void EditorSpatialGizmo::add_collision_segments(const Vector<Vector3> &p_lines) {
|
|
|
|
int from = collision_segments.size();
|
|
collision_segments.resize(from + p_lines.size());
|
|
for (int i = 0; i < p_lines.size(); i++) {
|
|
|
|
collision_segments.write[from + i] = p_lines[i];
|
|
}
|
|
}
|
|
|
|
void EditorSpatialGizmo::add_handles(const Vector<Vector3> &p_handles, const Ref<Material> &p_material, bool p_billboard, bool p_secondary) {
|
|
|
|
billboard_handle = p_billboard;
|
|
|
|
if (!is_selected() || !is_editable())
|
|
return;
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
|
|
Instance ins;
|
|
|
|
Ref<ArrayMesh> mesh = memnew(ArrayMesh);
|
|
|
|
Array a;
|
|
a.resize(VS::ARRAY_MAX);
|
|
a[VS::ARRAY_VERTEX] = p_handles;
|
|
PoolVector<Color> colors;
|
|
{
|
|
colors.resize(p_handles.size());
|
|
PoolVector<Color>::Write w = colors.write();
|
|
for (int i = 0; i < p_handles.size(); i++) {
|
|
|
|
Color col(1, 1, 1, 1);
|
|
if (is_handle_highlighted(i))
|
|
col = Color(0, 0, 1, 0.9);
|
|
|
|
if (SpatialEditor::get_singleton()->get_over_gizmo_handle() != i)
|
|
col.a = 0.8;
|
|
|
|
w[i] = col;
|
|
}
|
|
}
|
|
a[VS::ARRAY_COLOR] = colors;
|
|
mesh->add_surface_from_arrays(Mesh::PRIMITIVE_POINTS, a);
|
|
mesh->surface_set_material(0, p_material);
|
|
|
|
if (p_billboard) {
|
|
float md = 0;
|
|
for (int i = 0; i < p_handles.size(); i++) {
|
|
|
|
md = MAX(0, p_handles[i].length());
|
|
}
|
|
if (md) {
|
|
mesh->set_custom_aabb(AABB(Vector3(-md, -md, -md), Vector3(md, md, md) * 2.0));
|
|
}
|
|
}
|
|
|
|
ins.mesh = mesh;
|
|
ins.billboard = p_billboard;
|
|
ins.extra_margin = true;
|
|
if (valid) {
|
|
ins.create_instance(spatial_node, hidden);
|
|
VS::get_singleton()->instance_set_transform(ins.instance, spatial_node->get_global_transform());
|
|
}
|
|
instances.push_back(ins);
|
|
if (!p_secondary) {
|
|
int chs = handles.size();
|
|
handles.resize(chs + p_handles.size());
|
|
for (int i = 0; i < p_handles.size(); i++) {
|
|
handles.write[i + chs] = p_handles[i];
|
|
}
|
|
} else {
|
|
|
|
int chs = secondary_handles.size();
|
|
secondary_handles.resize(chs + p_handles.size());
|
|
for (int i = 0; i < p_handles.size(); i++) {
|
|
secondary_handles.write[i + chs] = p_handles[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
void EditorSpatialGizmo::add_solid_box(Ref<Material> &p_material, Vector3 p_size, Vector3 p_position) {
|
|
ERR_FAIL_COND(!spatial_node);
|
|
|
|
CubeMesh cubem;
|
|
cubem.set_size(p_size);
|
|
|
|
Array arrays = cubem.surface_get_arrays(0);
|
|
PoolVector3Array vertex = arrays[VS::ARRAY_VERTEX];
|
|
PoolVector3Array::Write w = vertex.write();
|
|
|
|
for (int i = 0; i < vertex.size(); ++i) {
|
|
w[i] += p_position;
|
|
}
|
|
|
|
arrays[VS::ARRAY_VERTEX] = vertex;
|
|
|
|
Ref<ArrayMesh> m = memnew(ArrayMesh);
|
|
m->add_surface_from_arrays(cubem.surface_get_primitive_type(0), arrays);
|
|
m->surface_set_material(0, p_material);
|
|
add_mesh(m);
|
|
}
|
|
|
|
bool EditorSpatialGizmo::intersect_frustum(const Camera *p_camera, const Vector<Plane> &p_frustum) {
|
|
|
|
ERR_FAIL_COND_V(!spatial_node, false);
|
|
ERR_FAIL_COND_V(!valid, false);
|
|
|
|
if (hidden && !gizmo_plugin->is_selectable_when_hidden()) return false;
|
|
|
|
if (selectable_icon_size > 0.0f) {
|
|
Vector3 origin = spatial_node->get_global_transform().get_origin();
|
|
|
|
const Plane *p = p_frustum.ptr();
|
|
int fc = p_frustum.size();
|
|
|
|
bool any_out = false;
|
|
|
|
for (int j = 0; j < fc; j++) {
|
|
|
|
if (p[j].is_point_over(origin)) {
|
|
any_out = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return !any_out;
|
|
}
|
|
|
|
if (collision_segments.size()) {
|
|
|
|
const Plane *p = p_frustum.ptr();
|
|
int fc = p_frustum.size();
|
|
|
|
int vc = collision_segments.size();
|
|
const Vector3 *vptr = collision_segments.ptr();
|
|
Transform t = spatial_node->get_global_transform();
|
|
|
|
bool any_out = false;
|
|
for (int j = 0; j < fc; j++) {
|
|
for (int i = 0; i < vc; i++) {
|
|
Vector3 v = t.xform(vptr[i]);
|
|
if (p[j].is_point_over(v)) {
|
|
any_out = true;
|
|
break;
|
|
}
|
|
}
|
|
if (any_out) break;
|
|
}
|
|
|
|
if (!any_out) return true;
|
|
}
|
|
|
|
if (collision_mesh.is_valid()) {
|
|
Transform t = spatial_node->get_global_transform();
|
|
|
|
Vector3 mesh_scale = t.get_basis().get_scale();
|
|
t.orthonormalize();
|
|
|
|
Transform it = t.affine_inverse();
|
|
|
|
Vector<Plane> transformed_frustum;
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
transformed_frustum.push_back(it.xform(p_frustum[i]));
|
|
}
|
|
|
|
if (collision_mesh->inside_convex_shape(transformed_frustum.ptr(), transformed_frustum.size(), mesh_scale)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool EditorSpatialGizmo::intersect_ray(Camera *p_camera, const Point2 &p_point, Vector3 &r_pos, Vector3 &r_normal, int *r_gizmo_handle, bool p_sec_first) {
|
|
|
|
ERR_FAIL_COND_V(!spatial_node, false);
|
|
ERR_FAIL_COND_V(!valid, false);
|
|
|
|
if (hidden && !gizmo_plugin->is_selectable_when_hidden()) return false;
|
|
|
|
if (r_gizmo_handle && !hidden) {
|
|
|
|
Transform t = spatial_node->get_global_transform();
|
|
t.orthonormalize();
|
|
if (billboard_handle) {
|
|
t.set_look_at(t.origin, t.origin - p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1));
|
|
}
|
|
|
|
float min_d = 1e20;
|
|
int idx = -1;
|
|
|
|
for (int i = 0; i < secondary_handles.size(); i++) {
|
|
|
|
Vector3 hpos = t.xform(secondary_handles[i]);
|
|
Vector2 p = p_camera->unproject_position(hpos);
|
|
|
|
if (p.distance_to(p_point) < HANDLE_HALF_SIZE) {
|
|
|
|
real_t dp = p_camera->get_transform().origin.distance_to(hpos);
|
|
if (dp < min_d) {
|
|
|
|
r_pos = t.xform(hpos);
|
|
r_normal = p_camera->get_transform().basis.get_axis(2);
|
|
min_d = dp;
|
|
idx = i + handles.size();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (p_sec_first && idx != -1) {
|
|
|
|
*r_gizmo_handle = idx;
|
|
return true;
|
|
}
|
|
|
|
min_d = 1e20;
|
|
|
|
for (int i = 0; i < handles.size(); i++) {
|
|
|
|
Vector3 hpos = t.xform(handles[i]);
|
|
Vector2 p = p_camera->unproject_position(hpos);
|
|
|
|
if (p.distance_to(p_point) < HANDLE_HALF_SIZE) {
|
|
|
|
real_t dp = p_camera->get_transform().origin.distance_to(hpos);
|
|
if (dp < min_d) {
|
|
|
|
r_pos = t.xform(hpos);
|
|
r_normal = p_camera->get_transform().basis.get_axis(2);
|
|
min_d = dp;
|
|
idx = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idx >= 0) {
|
|
*r_gizmo_handle = idx;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (selectable_icon_size > 0.0f) {
|
|
|
|
Transform t = spatial_node->get_global_transform();
|
|
t.orthonormalize();
|
|
Vector3 camera_position = p_camera->get_camera_transform().origin;
|
|
if (camera_position.distance_squared_to(t.origin) > 0.01) {
|
|
t.set_look_at(t.origin, camera_position, Vector3(0, 1, 0));
|
|
}
|
|
|
|
float scale = t.origin.distance_to(p_camera->get_camera_transform().origin);
|
|
|
|
if (p_camera->get_projection() == Camera::PROJECTION_ORTHOGONAL) {
|
|
float aspect = p_camera->get_viewport()->get_visible_rect().size.aspect();
|
|
float size = p_camera->get_size();
|
|
scale = size / aspect;
|
|
}
|
|
|
|
Point2 center = p_camera->unproject_position(t.origin);
|
|
|
|
Transform orig_camera_transform = p_camera->get_camera_transform();
|
|
|
|
if (orig_camera_transform.origin.distance_squared_to(t.origin) > 0.01 &&
|
|
ABS(orig_camera_transform.basis.get_axis(Vector3::AXIS_Z).dot(Vector3(0, 1, 0))) < 0.99) {
|
|
p_camera->look_at(t.origin, Vector3(0, 1, 0));
|
|
}
|
|
|
|
Vector3 c0 = t.xform(Vector3(selectable_icon_size, selectable_icon_size, 0) * scale);
|
|
Vector3 c1 = t.xform(Vector3(-selectable_icon_size, -selectable_icon_size, 0) * scale);
|
|
|
|
Point2 p0 = p_camera->unproject_position(c0);
|
|
Point2 p1 = p_camera->unproject_position(c1);
|
|
|
|
p_camera->set_global_transform(orig_camera_transform);
|
|
|
|
Rect2 rect(p0, (p1 - p0).abs());
|
|
|
|
rect.set_position(center - rect.get_size() / 2.0);
|
|
|
|
if (rect.has_point(p_point)) {
|
|
r_pos = t.origin;
|
|
r_normal = -p_camera->project_ray_normal(p_point);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (collision_segments.size()) {
|
|
|
|
Plane camp(p_camera->get_transform().origin, (-p_camera->get_transform().basis.get_axis(2)).normalized());
|
|
|
|
int vc = collision_segments.size();
|
|
const Vector3 *vptr = collision_segments.ptr();
|
|
Transform t = spatial_node->get_global_transform();
|
|
if (billboard_handle) {
|
|
t.set_look_at(t.origin, t.origin - p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1));
|
|
}
|
|
|
|
Vector3 cp;
|
|
float cpd = 1e20;
|
|
|
|
for (int i = 0; i < vc / 2; i++) {
|
|
|
|
Vector3 a = t.xform(vptr[i * 2 + 0]);
|
|
Vector3 b = t.xform(vptr[i * 2 + 1]);
|
|
Vector2 s[2];
|
|
s[0] = p_camera->unproject_position(a);
|
|
s[1] = p_camera->unproject_position(b);
|
|
|
|
Vector2 p = Geometry::get_closest_point_to_segment_2d(p_point, s);
|
|
|
|
float pd = p.distance_to(p_point);
|
|
|
|
if (pd < cpd) {
|
|
|
|
float d = s[0].distance_to(s[1]);
|
|
Vector3 tcp;
|
|
if (d > 0) {
|
|
|
|
float d2 = s[0].distance_to(p) / d;
|
|
tcp = a + (b - a) * d2;
|
|
|
|
} else {
|
|
tcp = a;
|
|
}
|
|
|
|
if (camp.distance_to(tcp) < p_camera->get_znear())
|
|
continue;
|
|
cp = tcp;
|
|
cpd = pd;
|
|
}
|
|
}
|
|
|
|
if (cpd < 8) {
|
|
|
|
r_pos = cp;
|
|
r_normal = -p_camera->project_ray_normal(p_point);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (collision_mesh.is_valid()) {
|
|
Transform gt = spatial_node->get_global_transform();
|
|
|
|
if (billboard_handle) {
|
|
gt.set_look_at(gt.origin, gt.origin - p_camera->get_transform().basis.get_axis(2), p_camera->get_transform().basis.get_axis(1));
|
|
}
|
|
|
|
Transform ai = gt.affine_inverse();
|
|
Vector3 ray_from = ai.xform(p_camera->project_ray_origin(p_point));
|
|
Vector3 ray_dir = ai.basis.xform(p_camera->project_ray_normal(p_point)).normalized();
|
|
Vector3 rpos, rnorm;
|
|
|
|
if (collision_mesh->intersect_ray(ray_from, ray_dir, rpos, rnorm)) {
|
|
|
|
r_pos = gt.xform(rpos);
|
|
r_normal = gt.basis.xform(rnorm).normalized();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void EditorSpatialGizmo::create() {
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
ERR_FAIL_COND(valid);
|
|
valid = true;
|
|
|
|
for (int i = 0; i < instances.size(); i++) {
|
|
|
|
instances.write[i].create_instance(spatial_node, hidden);
|
|
}
|
|
|
|
transform();
|
|
}
|
|
|
|
void EditorSpatialGizmo::transform() {
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
ERR_FAIL_COND(!valid);
|
|
for (int i = 0; i < instances.size(); i++) {
|
|
VS::get_singleton()->instance_set_transform(instances[i].instance, spatial_node->get_global_transform());
|
|
}
|
|
}
|
|
|
|
void EditorSpatialGizmo::free() {
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
ERR_FAIL_COND(!valid);
|
|
|
|
for (int i = 0; i < instances.size(); i++) {
|
|
|
|
if (instances[i].instance.is_valid())
|
|
VS::get_singleton()->free(instances[i].instance);
|
|
instances.write[i].instance = RID();
|
|
}
|
|
|
|
clear();
|
|
|
|
valid = false;
|
|
}
|
|
|
|
void EditorSpatialGizmo::set_hidden(bool p_hidden) {
|
|
hidden = p_hidden;
|
|
int layer = hidden ? 0 : 1 << SpatialEditorViewport::GIZMO_EDIT_LAYER;
|
|
for (int i = 0; i < instances.size(); ++i) {
|
|
VS::get_singleton()->instance_set_layer_mask(instances[i].instance, layer);
|
|
}
|
|
}
|
|
|
|
void EditorSpatialGizmo::set_plugin(EditorSpatialGizmoPlugin *p_plugin) {
|
|
gizmo_plugin = p_plugin;
|
|
}
|
|
|
|
void EditorSpatialGizmo::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("add_lines", "lines", "material", "billboard"), &EditorSpatialGizmo::add_lines, DEFVAL(false));
|
|
ClassDB::bind_method(D_METHOD("add_mesh", "mesh", "billboard", "skeleton", "material"), &EditorSpatialGizmo::add_mesh, DEFVAL(false), DEFVAL(RID()), DEFVAL(Variant()));
|
|
ClassDB::bind_method(D_METHOD("add_collision_segments", "segments"), &EditorSpatialGizmo::add_collision_segments);
|
|
ClassDB::bind_method(D_METHOD("add_collision_triangles", "triangles"), &EditorSpatialGizmo::add_collision_triangles);
|
|
ClassDB::bind_method(D_METHOD("add_unscaled_billboard", "material", "default_scale"), &EditorSpatialGizmo::add_unscaled_billboard, DEFVAL(1));
|
|
ClassDB::bind_method(D_METHOD("add_handles", "handles", "material", "billboard", "secondary"), &EditorSpatialGizmo::add_handles, DEFVAL(false), DEFVAL(false));
|
|
ClassDB::bind_method(D_METHOD("set_spatial_node", "node"), &EditorSpatialGizmo::_set_spatial_node);
|
|
ClassDB::bind_method(D_METHOD("get_spatial_node"), &EditorSpatialGizmo::get_spatial_node);
|
|
ClassDB::bind_method(D_METHOD("get_plugin"), &EditorSpatialGizmo::get_plugin);
|
|
ClassDB::bind_method(D_METHOD("clear"), &EditorSpatialGizmo::clear);
|
|
ClassDB::bind_method(D_METHOD("set_hidden", "hidden"), &EditorSpatialGizmo::set_hidden);
|
|
|
|
BIND_VMETHOD(MethodInfo("redraw"));
|
|
BIND_VMETHOD(MethodInfo(Variant::STRING, "get_handle_name", PropertyInfo(Variant::INT, "index")));
|
|
BIND_VMETHOD(MethodInfo(Variant::BOOL, "is_handle_highlighted", PropertyInfo(Variant::INT, "index")));
|
|
|
|
MethodInfo hvget(Variant::NIL, "get_handle_value", PropertyInfo(Variant::INT, "index"));
|
|
hvget.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
|
|
BIND_VMETHOD(hvget);
|
|
|
|
BIND_VMETHOD(MethodInfo("set_handle", PropertyInfo(Variant::INT, "index"), PropertyInfo(Variant::OBJECT, "camera", PROPERTY_HINT_RESOURCE_TYPE, "Camera"), PropertyInfo(Variant::VECTOR2, "point")));
|
|
MethodInfo cm = MethodInfo("commit_handle", PropertyInfo(Variant::INT, "index"), PropertyInfo(Variant::NIL, "restore"), PropertyInfo(Variant::BOOL, "cancel"));
|
|
cm.default_arguments.push_back(false);
|
|
BIND_VMETHOD(cm);
|
|
}
|
|
|
|
EditorSpatialGizmo::EditorSpatialGizmo() {
|
|
valid = false;
|
|
billboard_handle = false;
|
|
hidden = false;
|
|
base = NULL;
|
|
selected = false;
|
|
instanced = false;
|
|
spatial_node = NULL;
|
|
gizmo_plugin = NULL;
|
|
selectable_icon_size = -1.0f;
|
|
}
|
|
|
|
EditorSpatialGizmo::~EditorSpatialGizmo() {
|
|
|
|
if (gizmo_plugin != NULL) gizmo_plugin->unregister_gizmo(this);
|
|
clear();
|
|
}
|
|
|
|
Vector3 EditorSpatialGizmo::get_handle_pos(int p_idx) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_idx, handles.size(), Vector3());
|
|
|
|
return handles[p_idx];
|
|
}
|
|
|
|
//// light gizmo
|
|
|
|
LightSpatialGizmoPlugin::LightSpatialGizmoPlugin() {
|
|
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/light", Color(1, 1, 0.7));
|
|
|
|
create_material("lines_primary", gizmo_color);
|
|
create_material("lines_secondary", gizmo_color * Color(1, 1, 1, 0.35));
|
|
create_material("lines_billboard", gizmo_color, true);
|
|
|
|
create_icon_material("light_directional_icon", SpatialEditor::get_singleton()->get_icon("GizmoDirectionalLight", "EditorIcons"));
|
|
create_icon_material("light_omni_icon", SpatialEditor::get_singleton()->get_icon("GizmoLight", "EditorIcons"));
|
|
create_icon_material("light_spot_icon", SpatialEditor::get_singleton()->get_icon("GizmoSpotLight", "EditorIcons"));
|
|
|
|
create_handle_material("handles");
|
|
create_handle_material("handles_billboard", true);
|
|
}
|
|
|
|
bool LightSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<Light>(p_spatial) != NULL;
|
|
}
|
|
|
|
String LightSpatialGizmoPlugin::get_name() const {
|
|
return "Lights";
|
|
}
|
|
|
|
int LightSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
String LightSpatialGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
if (p_idx == 0)
|
|
return "Radius";
|
|
else
|
|
return "Aperture";
|
|
}
|
|
|
|
Variant LightSpatialGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
Light *light = Object::cast_to<Light>(p_gizmo->get_spatial_node());
|
|
if (p_idx == 0)
|
|
return light->get_param(Light::PARAM_RANGE);
|
|
if (p_idx == 1)
|
|
return light->get_param(Light::PARAM_SPOT_ANGLE);
|
|
|
|
return Variant();
|
|
}
|
|
|
|
static float _find_closest_angle_to_half_pi_arc(const Vector3 &p_from, const Vector3 &p_to, float p_arc_radius, const Transform &p_arc_xform) {
|
|
|
|
//bleh, discrete is simpler
|
|
static const int arc_test_points = 64;
|
|
float min_d = 1e20;
|
|
Vector3 min_p;
|
|
|
|
for (int i = 0; i < arc_test_points; i++) {
|
|
|
|
float a = i * Math_PI * 0.5 / arc_test_points;
|
|
float an = (i + 1) * Math_PI * 0.5 / arc_test_points;
|
|
Vector3 p = Vector3(Math::cos(a), 0, -Math::sin(a)) * p_arc_radius;
|
|
Vector3 n = Vector3(Math::cos(an), 0, -Math::sin(an)) * p_arc_radius;
|
|
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(p, n, p_from, p_to, ra, rb);
|
|
|
|
float d = ra.distance_to(rb);
|
|
if (d < min_d) {
|
|
min_d = d;
|
|
min_p = ra;
|
|
}
|
|
}
|
|
|
|
//min_p = p_arc_xform.affine_inverse().xform(min_p);
|
|
float a = (Math_PI * 0.5) - Vector2(min_p.x, -min_p.z).angle();
|
|
return a * 180.0 / Math_PI;
|
|
}
|
|
|
|
void LightSpatialGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
Light *light = Object::cast_to<Light>(p_gizmo->get_spatial_node());
|
|
Transform gt = light->get_global_transform();
|
|
gt.orthonormalize();
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 s[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 4096) };
|
|
if (p_idx == 0) {
|
|
|
|
if (Object::cast_to<SpotLight>(light)) {
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), Vector3(0, 0, -4096), s[0], s[1], ra, rb);
|
|
|
|
float d = -ra.z;
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0)
|
|
d = 0;
|
|
|
|
light->set_param(Light::PARAM_RANGE, d);
|
|
} else if (Object::cast_to<OmniLight>(light)) {
|
|
|
|
Plane cp = Plane(gt.origin, p_camera->get_transform().basis.get_axis(2));
|
|
|
|
Vector3 inters;
|
|
if (cp.intersects_ray(ray_from, ray_dir, &inters)) {
|
|
|
|
float r = inters.distance_to(gt.origin);
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
r = Math::stepify(r, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
light->set_param(Light::PARAM_RANGE, r);
|
|
}
|
|
}
|
|
|
|
} else if (p_idx == 1) {
|
|
|
|
float a = _find_closest_angle_to_half_pi_arc(s[0], s[1], light->get_param(Light::PARAM_RANGE), gt);
|
|
light->set_param(Light::PARAM_SPOT_ANGLE, CLAMP(a, 0.01, 89.99));
|
|
}
|
|
}
|
|
|
|
void LightSpatialGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
Light *light = Object::cast_to<Light>(p_gizmo->get_spatial_node());
|
|
if (p_cancel) {
|
|
|
|
light->set_param(p_idx == 0 ? Light::PARAM_RANGE : Light::PARAM_SPOT_ANGLE, p_restore);
|
|
|
|
} else if (p_idx == 0) {
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Light Radius"));
|
|
ur->add_do_method(light, "set_param", Light::PARAM_RANGE, light->get_param(Light::PARAM_RANGE));
|
|
ur->add_undo_method(light, "set_param", Light::PARAM_RANGE, p_restore);
|
|
ur->commit_action();
|
|
} else if (p_idx == 1) {
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Light Radius"));
|
|
ur->add_do_method(light, "set_param", Light::PARAM_SPOT_ANGLE, light->get_param(Light::PARAM_SPOT_ANGLE));
|
|
ur->add_undo_method(light, "set_param", Light::PARAM_SPOT_ANGLE, p_restore);
|
|
ur->commit_action();
|
|
}
|
|
}
|
|
|
|
void LightSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
Light *light = Object::cast_to<Light>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
if (Object::cast_to<DirectionalLight>(light)) {
|
|
|
|
Ref<Material> material = get_material("lines_primary", p_gizmo);
|
|
Ref<Material> icon = get_material("light_directional_icon", p_gizmo);
|
|
|
|
const int arrow_points = 7;
|
|
const float arrow_length = 1.5;
|
|
|
|
Vector3 arrow[arrow_points] = {
|
|
Vector3(0, 0, -1),
|
|
Vector3(0, 0.8, 0),
|
|
Vector3(0, 0.3, 0),
|
|
Vector3(0, 0.3, arrow_length),
|
|
Vector3(0, -0.3, arrow_length),
|
|
Vector3(0, -0.3, 0),
|
|
Vector3(0, -0.8, 0)
|
|
};
|
|
|
|
int arrow_sides = 2;
|
|
|
|
Vector<Vector3> lines;
|
|
|
|
for (int i = 0; i < arrow_sides; i++) {
|
|
for (int j = 0; j < arrow_points; j++) {
|
|
Basis ma(Vector3(0, 0, 1), Math_PI * i / arrow_sides);
|
|
|
|
Vector3 v1 = arrow[j] - Vector3(0, 0, arrow_length);
|
|
Vector3 v2 = arrow[(j + 1) % arrow_points] - Vector3(0, 0, arrow_length);
|
|
|
|
lines.push_back(ma.xform(v1));
|
|
lines.push_back(ma.xform(v2));
|
|
}
|
|
}
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
}
|
|
|
|
if (Object::cast_to<OmniLight>(light)) {
|
|
|
|
// Use both a billboard circle and 3 non-billboard circles for a better sphere-like representation
|
|
const Ref<Material> lines_material = get_material("lines_secondary", p_gizmo);
|
|
const Ref<Material> lines_billboard_material = get_material("lines_billboard", p_gizmo);
|
|
const Ref<Material> icon = get_material("light_omni_icon", p_gizmo);
|
|
|
|
OmniLight *on = Object::cast_to<OmniLight>(light);
|
|
const float r = on->get_param(Light::PARAM_RANGE);
|
|
Vector<Vector3> points;
|
|
Vector<Vector3> points_billboard;
|
|
|
|
for (int i = 0; i < 120; i++) {
|
|
|
|
// Create a circle
|
|
const float ra = Math::deg2rad((float)(i * 3));
|
|
const float rb = Math::deg2rad((float)((i + 1) * 3));
|
|
const Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * r;
|
|
const Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * r;
|
|
|
|
// Draw axis-aligned circles
|
|
points.push_back(Vector3(a.x, 0, a.y));
|
|
points.push_back(Vector3(b.x, 0, b.y));
|
|
points.push_back(Vector3(0, a.x, a.y));
|
|
points.push_back(Vector3(0, b.x, b.y));
|
|
points.push_back(Vector3(a.x, a.y, 0));
|
|
points.push_back(Vector3(b.x, b.y, 0));
|
|
|
|
// Draw a billboarded circle
|
|
points_billboard.push_back(Vector3(a.x, a.y, 0));
|
|
points_billboard.push_back(Vector3(b.x, b.y, 0));
|
|
}
|
|
|
|
p_gizmo->add_lines(points, lines_material, true);
|
|
p_gizmo->add_lines(points_billboard, lines_billboard_material, true);
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(r, 0, 0));
|
|
p_gizmo->add_handles(handles, get_material("handles_billboard"), true);
|
|
}
|
|
|
|
if (Object::cast_to<SpotLight>(light)) {
|
|
|
|
const Ref<Material> material_primary = get_material("lines_primary", p_gizmo);
|
|
const Ref<Material> material_secondary = get_material("lines_secondary", p_gizmo);
|
|
const Ref<Material> icon = get_material("light_spot_icon", p_gizmo);
|
|
|
|
Vector<Vector3> points_primary;
|
|
Vector<Vector3> points_secondary;
|
|
SpotLight *sl = Object::cast_to<SpotLight>(light);
|
|
|
|
float r = sl->get_param(Light::PARAM_RANGE);
|
|
float w = r * Math::sin(Math::deg2rad(sl->get_param(Light::PARAM_SPOT_ANGLE)));
|
|
float d = r * Math::cos(Math::deg2rad(sl->get_param(Light::PARAM_SPOT_ANGLE)));
|
|
|
|
for (int i = 0; i < 120; i++) {
|
|
|
|
// Draw a circle
|
|
const float ra = Math::deg2rad((float)(i * 3));
|
|
const float rb = Math::deg2rad((float)((i + 1) * 3));
|
|
const Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * w;
|
|
const Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * w;
|
|
|
|
points_primary.push_back(Vector3(a.x, a.y, -d));
|
|
points_primary.push_back(Vector3(b.x, b.y, -d));
|
|
|
|
if (i % 15 == 0) {
|
|
// Draw 8 lines from the cone origin to the sides of the circle
|
|
points_secondary.push_back(Vector3(a.x, a.y, -d));
|
|
points_secondary.push_back(Vector3());
|
|
}
|
|
}
|
|
|
|
points_primary.push_back(Vector3(0, 0, -r));
|
|
points_primary.push_back(Vector3());
|
|
|
|
p_gizmo->add_lines(points_primary, material_primary);
|
|
p_gizmo->add_lines(points_secondary, material_secondary);
|
|
|
|
const float ra = 16 * Math_PI * 2.0 / 64.0;
|
|
const Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * w;
|
|
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(0, 0, -r));
|
|
handles.push_back(Vector3(a.x, a.y, -d));
|
|
|
|
p_gizmo->add_handles(handles, get_material("handles"));
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
}
|
|
}
|
|
|
|
//////
|
|
|
|
//// player gizmo
|
|
AudioStreamPlayer3DSpatialGizmoPlugin::AudioStreamPlayer3DSpatialGizmoPlugin() {
|
|
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/stream_player_3d", Color(0.4, 0.8, 1));
|
|
|
|
create_icon_material("stream_player_3d_icon", SpatialEditor::get_singleton()->get_icon("GizmoSpatialSamplePlayer", "EditorIcons"));
|
|
create_material("stream_player_3d_material", gizmo_color);
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
bool AudioStreamPlayer3DSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<AudioStreamPlayer3D>(p_spatial) != NULL;
|
|
}
|
|
|
|
String AudioStreamPlayer3DSpatialGizmoPlugin::get_name() const {
|
|
return "AudioStreamPlayer3D";
|
|
}
|
|
|
|
int AudioStreamPlayer3DSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
String AudioStreamPlayer3DSpatialGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
return "Emission Radius";
|
|
}
|
|
|
|
Variant AudioStreamPlayer3DSpatialGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
AudioStreamPlayer3D *player = Object::cast_to<AudioStreamPlayer3D>(p_gizmo->get_spatial_node());
|
|
return player->get_emission_angle();
|
|
}
|
|
|
|
void AudioStreamPlayer3DSpatialGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
AudioStreamPlayer3D *player = Object::cast_to<AudioStreamPlayer3D>(p_gizmo->get_spatial_node());
|
|
|
|
Transform gt = player->get_global_transform();
|
|
gt.orthonormalize();
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
Vector3 ray_to = ray_from + ray_dir * 4096;
|
|
|
|
ray_from = gi.xform(ray_from);
|
|
ray_to = gi.xform(ray_to);
|
|
|
|
float closest_dist = 1e20;
|
|
float closest_angle = 1e20;
|
|
|
|
for (int i = 0; i < 180; i++) {
|
|
|
|
float a = i * Math_PI / 180.0;
|
|
float an = (i + 1) * Math_PI / 180.0;
|
|
|
|
Vector3 from(Math::sin(a), 0, -Math::cos(a));
|
|
Vector3 to(Math::sin(an), 0, -Math::cos(an));
|
|
|
|
Vector3 r1, r2;
|
|
Geometry::get_closest_points_between_segments(from, to, ray_from, ray_to, r1, r2);
|
|
float d = r1.distance_to(r2);
|
|
if (d < closest_dist) {
|
|
closest_dist = d;
|
|
closest_angle = i;
|
|
}
|
|
}
|
|
|
|
if (closest_angle < 91) {
|
|
player->set_emission_angle(closest_angle);
|
|
}
|
|
}
|
|
|
|
void AudioStreamPlayer3DSpatialGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
AudioStreamPlayer3D *player = Object::cast_to<AudioStreamPlayer3D>(p_gizmo->get_spatial_node());
|
|
|
|
if (p_cancel) {
|
|
|
|
player->set_emission_angle(p_restore);
|
|
|
|
} else {
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change AudioStreamPlayer3D Emission Angle"));
|
|
ur->add_do_method(player, "set_emission_angle", player->get_emission_angle());
|
|
ur->add_undo_method(player, "set_emission_angle", p_restore);
|
|
ur->commit_action();
|
|
}
|
|
}
|
|
|
|
void AudioStreamPlayer3DSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
AudioStreamPlayer3D *player = Object::cast_to<AudioStreamPlayer3D>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Ref<Material> icon = get_material("stream_player_3d_icon", p_gizmo);
|
|
|
|
if (player->is_emission_angle_enabled()) {
|
|
|
|
Ref<Material> material = get_material("stream_player_3d_material", p_gizmo);
|
|
|
|
float pc = player->get_emission_angle();
|
|
|
|
Vector<Vector3> points;
|
|
points.resize(208);
|
|
|
|
float ofs = -Math::cos(Math::deg2rad(pc));
|
|
float radius = Math::sin(Math::deg2rad(pc));
|
|
|
|
for (int i = 0; i < 100; i++) {
|
|
|
|
float a = i * 2.0 * Math_PI / 100.0;
|
|
float an = (i + 1) * 2.0 * Math_PI / 100.0;
|
|
|
|
Vector3 from(Math::sin(a) * radius, Math::cos(a) * radius, ofs);
|
|
Vector3 to(Math::sin(an) * radius, Math::cos(an) * radius, ofs);
|
|
|
|
points.write[i * 2 + 0] = from;
|
|
points.write[i * 2 + 1] = to;
|
|
}
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
|
|
float a = i * 2.0 * Math_PI / 4.0;
|
|
|
|
Vector3 from(Math::sin(a) * radius, Math::cos(a) * radius, ofs);
|
|
|
|
points.write[200 + i * 2 + 0] = from;
|
|
points.write[200 + i * 2 + 1] = Vector3();
|
|
}
|
|
|
|
p_gizmo->add_lines(points, material);
|
|
|
|
Vector<Vector3> handles;
|
|
float ha = Math::deg2rad(player->get_emission_angle());
|
|
handles.push_back(Vector3(Math::sin(ha), 0, -Math::cos(ha)));
|
|
p_gizmo->add_handles(handles, get_material("handles"));
|
|
}
|
|
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
}
|
|
|
|
//////
|
|
|
|
CameraSpatialGizmoPlugin::CameraSpatialGizmoPlugin() {
|
|
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/camera", Color(0.8, 0.4, 0.8));
|
|
|
|
create_material("camera_material", gizmo_color);
|
|
create_icon_material("camera_icon", SpatialEditor::get_singleton()->get_icon("GizmoCamera", "EditorIcons"));
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
bool CameraSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<Camera>(p_spatial) != NULL;
|
|
}
|
|
|
|
String CameraSpatialGizmoPlugin::get_name() const {
|
|
return "Camera";
|
|
}
|
|
|
|
int CameraSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
String CameraSpatialGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
Camera *camera = Object::cast_to<Camera>(p_gizmo->get_spatial_node());
|
|
|
|
if (camera->get_projection() == Camera::PROJECTION_PERSPECTIVE) {
|
|
return "FOV";
|
|
} else {
|
|
return "Size";
|
|
}
|
|
}
|
|
|
|
Variant CameraSpatialGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
Camera *camera = Object::cast_to<Camera>(p_gizmo->get_spatial_node());
|
|
|
|
if (camera->get_projection() == Camera::PROJECTION_PERSPECTIVE) {
|
|
return camera->get_fov();
|
|
} else {
|
|
|
|
return camera->get_size();
|
|
}
|
|
}
|
|
|
|
void CameraSpatialGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
Camera *camera = Object::cast_to<Camera>(p_gizmo->get_spatial_node());
|
|
|
|
Transform gt = camera->get_global_transform();
|
|
gt.orthonormalize();
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 s[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 4096) };
|
|
|
|
if (camera->get_projection() == Camera::PROJECTION_PERSPECTIVE) {
|
|
Transform gt2 = camera->get_global_transform();
|
|
float a = _find_closest_angle_to_half_pi_arc(s[0], s[1], 1.0, gt2);
|
|
camera->set("fov", a * 2.0);
|
|
} else {
|
|
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(0, 0, -1), Vector3(4096, 0, -1), s[0], s[1], ra, rb);
|
|
float d = ra.x * 2.0;
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0)
|
|
d = 0;
|
|
|
|
camera->set("size", d);
|
|
}
|
|
}
|
|
|
|
void CameraSpatialGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
Camera *camera = Object::cast_to<Camera>(p_gizmo->get_spatial_node());
|
|
|
|
if (camera->get_projection() == Camera::PROJECTION_PERSPECTIVE) {
|
|
|
|
if (p_cancel) {
|
|
|
|
camera->set("fov", p_restore);
|
|
} else {
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Camera FOV"));
|
|
ur->add_do_property(camera, "fov", camera->get_fov());
|
|
ur->add_undo_property(camera, "fov", p_restore);
|
|
ur->commit_action();
|
|
}
|
|
|
|
} else {
|
|
|
|
if (p_cancel) {
|
|
|
|
camera->set("size", p_restore);
|
|
} else {
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Camera Size"));
|
|
ur->add_do_property(camera, "size", camera->get_size());
|
|
ur->add_undo_property(camera, "size", p_restore);
|
|
ur->commit_action();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CameraSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
Camera *camera = Object::cast_to<Camera>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> lines;
|
|
Vector<Vector3> handles;
|
|
|
|
Ref<Material> material = get_material("camera_material", p_gizmo);
|
|
Ref<Material> icon = get_material("camera_icon", p_gizmo);
|
|
|
|
#define ADD_TRIANGLE(m_a, m_b, m_c) \
|
|
{ \
|
|
lines.push_back(m_a); \
|
|
lines.push_back(m_b); \
|
|
lines.push_back(m_b); \
|
|
lines.push_back(m_c); \
|
|
lines.push_back(m_c); \
|
|
lines.push_back(m_a); \
|
|
}
|
|
|
|
#define ADD_QUAD(m_a, m_b, m_c, m_d) \
|
|
{ \
|
|
lines.push_back(m_a); \
|
|
lines.push_back(m_b); \
|
|
lines.push_back(m_b); \
|
|
lines.push_back(m_c); \
|
|
lines.push_back(m_c); \
|
|
lines.push_back(m_d); \
|
|
lines.push_back(m_d); \
|
|
lines.push_back(m_a); \
|
|
}
|
|
|
|
switch (camera->get_projection()) {
|
|
|
|
case Camera::PROJECTION_PERSPECTIVE: {
|
|
|
|
// The real FOV is halved for accurate representation
|
|
float fov = camera->get_fov() / 2.0;
|
|
|
|
Vector3 side = Vector3(Math::sin(Math::deg2rad(fov)), 0, -Math::cos(Math::deg2rad(fov)));
|
|
Vector3 nside = side;
|
|
nside.x = -nside.x;
|
|
Vector3 up = Vector3(0, side.x, 0);
|
|
|
|
ADD_TRIANGLE(Vector3(), side + up, side - up);
|
|
ADD_TRIANGLE(Vector3(), nside + up, nside - up);
|
|
ADD_TRIANGLE(Vector3(), side + up, nside + up);
|
|
ADD_TRIANGLE(Vector3(), side - up, nside - up);
|
|
|
|
handles.push_back(side);
|
|
side.x *= 0.25;
|
|
nside.x *= 0.25;
|
|
Vector3 tup(0, up.y * 3 / 2, side.z);
|
|
ADD_TRIANGLE(tup, side + up, nside + up);
|
|
|
|
} break;
|
|
case Camera::PROJECTION_ORTHOGONAL: {
|
|
|
|
float size = camera->get_size();
|
|
|
|
float hsize = size * 0.5;
|
|
Vector3 right(hsize, 0, 0);
|
|
Vector3 up(0, hsize, 0);
|
|
Vector3 back(0, 0, -1.0);
|
|
Vector3 front(0, 0, 0);
|
|
|
|
ADD_QUAD(-up - right, -up + right, up + right, up - right);
|
|
ADD_QUAD(-up - right + back, -up + right + back, up + right + back, up - right + back);
|
|
ADD_QUAD(up + right, up + right + back, up - right + back, up - right);
|
|
ADD_QUAD(-up + right, -up + right + back, -up - right + back, -up - right);
|
|
|
|
handles.push_back(right + back);
|
|
|
|
right.x *= 0.25;
|
|
Vector3 tup(0, up.y * 3 / 2, back.z);
|
|
ADD_TRIANGLE(tup, right + up + back, -right + up + back);
|
|
|
|
} break;
|
|
case Camera::PROJECTION_FRUSTUM: {
|
|
float hsize = camera->get_size() / 2.0;
|
|
|
|
Vector3 side = Vector3(hsize, 0, -camera->get_znear()).normalized();
|
|
Vector3 nside = side;
|
|
nside.x = -nside.x;
|
|
Vector3 up = Vector3(0, side.x, 0);
|
|
Vector3 offset = Vector3(camera->get_frustum_offset().x, camera->get_frustum_offset().y, 0.0);
|
|
|
|
ADD_TRIANGLE(Vector3(), side + up + offset, side - up + offset);
|
|
ADD_TRIANGLE(Vector3(), nside + up + offset, nside - up + offset);
|
|
ADD_TRIANGLE(Vector3(), side + up + offset, nside + up + offset);
|
|
ADD_TRIANGLE(Vector3(), side - up + offset, nside - up + offset);
|
|
|
|
side.x *= 0.25;
|
|
nside.x *= 0.25;
|
|
Vector3 tup(0, up.y * 3 / 2, side.z);
|
|
ADD_TRIANGLE(tup + offset, side + up + offset, nside + up + offset);
|
|
}
|
|
}
|
|
|
|
#undef ADD_TRIANGLE
|
|
#undef ADD_QUAD
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
p_gizmo->add_handles(handles, get_material("handles"));
|
|
|
|
ClippedCamera *clipcam = Object::cast_to<ClippedCamera>(camera);
|
|
if (clipcam) {
|
|
Spatial *parent = Object::cast_to<Spatial>(camera->get_parent());
|
|
if (!parent) {
|
|
return;
|
|
}
|
|
Vector3 cam_normal = -camera->get_global_transform().basis.get_axis(Vector3::AXIS_Z).normalized();
|
|
Vector3 cam_x = camera->get_global_transform().basis.get_axis(Vector3::AXIS_X).normalized();
|
|
Vector3 cam_y = camera->get_global_transform().basis.get_axis(Vector3::AXIS_Y).normalized();
|
|
Vector3 cam_pos = camera->get_global_transform().origin;
|
|
Vector3 parent_pos = parent->get_global_transform().origin;
|
|
|
|
Plane parent_plane(parent_pos, cam_normal);
|
|
Vector3 ray_from = parent_plane.project(cam_pos);
|
|
|
|
lines.clear();
|
|
lines.push_back(ray_from + cam_x * 0.5 + cam_y * 0.5);
|
|
lines.push_back(ray_from + cam_x * 0.5 + cam_y * -0.5);
|
|
|
|
lines.push_back(ray_from + cam_x * 0.5 + cam_y * -0.5);
|
|
lines.push_back(ray_from + cam_x * -0.5 + cam_y * -0.5);
|
|
|
|
lines.push_back(ray_from + cam_x * -0.5 + cam_y * -0.5);
|
|
lines.push_back(ray_from + cam_x * -0.5 + cam_y * 0.5);
|
|
|
|
lines.push_back(ray_from + cam_x * -0.5 + cam_y * 0.5);
|
|
lines.push_back(ray_from + cam_x * 0.5 + cam_y * 0.5);
|
|
|
|
if (parent_plane.distance_to(cam_pos) < 0) {
|
|
lines.push_back(ray_from);
|
|
lines.push_back(cam_pos);
|
|
}
|
|
|
|
Transform local = camera->get_global_transform().affine_inverse();
|
|
for (int i = 0; i < lines.size(); i++) {
|
|
lines.write[i] = local.xform(lines[i]);
|
|
}
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
}
|
|
}
|
|
|
|
//////
|
|
|
|
MeshInstanceSpatialGizmoPlugin::MeshInstanceSpatialGizmoPlugin() {
|
|
}
|
|
|
|
bool MeshInstanceSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<MeshInstance>(p_spatial) != NULL && Object::cast_to<SoftBody>(p_spatial) == NULL;
|
|
}
|
|
|
|
String MeshInstanceSpatialGizmoPlugin::get_name() const {
|
|
return "MeshInstance";
|
|
}
|
|
|
|
int MeshInstanceSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
bool MeshInstanceSpatialGizmoPlugin::can_be_hidden() const {
|
|
return false;
|
|
}
|
|
|
|
void MeshInstanceSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
MeshInstance *mesh = Object::cast_to<MeshInstance>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Ref<Mesh> m = mesh->get_mesh();
|
|
|
|
if (!m.is_valid())
|
|
return; //none
|
|
|
|
Ref<TriangleMesh> tm = m->generate_triangle_mesh();
|
|
if (tm.is_valid()) {
|
|
p_gizmo->add_collision_triangles(tm);
|
|
}
|
|
}
|
|
|
|
/////
|
|
Sprite3DSpatialGizmoPlugin::Sprite3DSpatialGizmoPlugin() {
|
|
}
|
|
|
|
bool Sprite3DSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<Sprite3D>(p_spatial) != NULL;
|
|
}
|
|
|
|
String Sprite3DSpatialGizmoPlugin::get_name() const {
|
|
return "Sprite3D";
|
|
}
|
|
|
|
int Sprite3DSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
bool Sprite3DSpatialGizmoPlugin::can_be_hidden() const {
|
|
return false;
|
|
}
|
|
|
|
void Sprite3DSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
Sprite3D *sprite = Object::cast_to<Sprite3D>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Ref<TriangleMesh> tm = sprite->generate_triangle_mesh();
|
|
if (tm.is_valid()) {
|
|
p_gizmo->add_collision_triangles(tm);
|
|
}
|
|
}
|
|
|
|
///
|
|
|
|
Position3DSpatialGizmoPlugin::Position3DSpatialGizmoPlugin() {
|
|
pos3d_mesh = Ref<ArrayMesh>(memnew(ArrayMesh));
|
|
cursor_points = Vector<Vector3>();
|
|
|
|
PoolVector<Color> cursor_colors;
|
|
float cs = 0.25;
|
|
cursor_points.push_back(Vector3(+cs, 0, 0));
|
|
cursor_points.push_back(Vector3(-cs, 0, 0));
|
|
cursor_points.push_back(Vector3(0, +cs, 0));
|
|
cursor_points.push_back(Vector3(0, -cs, 0));
|
|
cursor_points.push_back(Vector3(0, 0, +cs));
|
|
cursor_points.push_back(Vector3(0, 0, -cs));
|
|
cursor_colors.push_back(Color(1, 0.5, 0.5, 0.7));
|
|
cursor_colors.push_back(Color(1, 0.5, 0.5, 0.7));
|
|
cursor_colors.push_back(Color(0.5, 1, 0.5, 0.7));
|
|
cursor_colors.push_back(Color(0.5, 1, 0.5, 0.7));
|
|
cursor_colors.push_back(Color(0.5, 0.5, 1, 0.7));
|
|
cursor_colors.push_back(Color(0.5, 0.5, 1, 0.7));
|
|
|
|
Ref<SpatialMaterial> mat = memnew(SpatialMaterial);
|
|
mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
|
|
mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
|
|
mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
|
|
mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
|
|
mat->set_line_width(3);
|
|
Array d;
|
|
d.resize(VS::ARRAY_MAX);
|
|
d[Mesh::ARRAY_VERTEX] = cursor_points;
|
|
d[Mesh::ARRAY_COLOR] = cursor_colors;
|
|
pos3d_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_LINES, d);
|
|
pos3d_mesh->surface_set_material(0, mat);
|
|
}
|
|
|
|
bool Position3DSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<Position3D>(p_spatial) != NULL;
|
|
}
|
|
|
|
String Position3DSpatialGizmoPlugin::get_name() const {
|
|
return "Position3D";
|
|
}
|
|
|
|
int Position3DSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void Position3DSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
p_gizmo->clear();
|
|
p_gizmo->add_mesh(pos3d_mesh);
|
|
p_gizmo->add_collision_segments(cursor_points);
|
|
}
|
|
|
|
/////
|
|
|
|
SkeletonSpatialGizmoPlugin::SkeletonSpatialGizmoPlugin() {
|
|
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/skeleton", Color(1, 0.8, 0.4));
|
|
create_material("skeleton_material", gizmo_color);
|
|
}
|
|
|
|
bool SkeletonSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<Skeleton>(p_spatial) != NULL;
|
|
}
|
|
|
|
String SkeletonSpatialGizmoPlugin::get_name() const {
|
|
return "Skeleton";
|
|
}
|
|
|
|
int SkeletonSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void SkeletonSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
Skeleton *skel = Object::cast_to<Skeleton>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Ref<Material> material = get_material("skeleton_material", p_gizmo);
|
|
|
|
Ref<SurfaceTool> surface_tool(memnew(SurfaceTool));
|
|
|
|
surface_tool->begin(Mesh::PRIMITIVE_LINES);
|
|
surface_tool->set_material(material);
|
|
Vector<Transform> grests;
|
|
grests.resize(skel->get_bone_count());
|
|
|
|
Vector<int> bones;
|
|
Vector<float> weights;
|
|
bones.resize(4);
|
|
weights.resize(4);
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
bones.write[i] = 0;
|
|
weights.write[i] = 0;
|
|
}
|
|
|
|
weights.write[0] = 1;
|
|
|
|
AABB aabb;
|
|
|
|
Color bonecolor = Color(1.0, 0.4, 0.4, 0.3);
|
|
Color rootcolor = Color(0.4, 1.0, 0.4, 0.1);
|
|
|
|
for (int i_bone = 0; i_bone < skel->get_bone_count(); i_bone++) {
|
|
|
|
int i = skel->get_process_order(i_bone);
|
|
|
|
int parent = skel->get_bone_parent(i);
|
|
|
|
if (parent >= 0) {
|
|
grests.write[i] = grests[parent] * skel->get_bone_rest(i);
|
|
|
|
Vector3 v0 = grests[parent].origin;
|
|
Vector3 v1 = grests[i].origin;
|
|
Vector3 d = (v1 - v0).normalized();
|
|
float dist = v0.distance_to(v1);
|
|
|
|
//find closest axis
|
|
int closest = -1;
|
|
float closest_d = 0.0;
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
float dp = Math::abs(grests[parent].basis[j].normalized().dot(d));
|
|
if (j == 0 || dp > closest_d)
|
|
closest = j;
|
|
}
|
|
|
|
//find closest other
|
|
Vector3 first;
|
|
Vector3 points[4];
|
|
int pointidx = 0;
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
bones.write[0] = parent;
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(rootcolor);
|
|
surface_tool->add_vertex(v0 - grests[parent].basis[j].normalized() * dist * 0.05);
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(rootcolor);
|
|
surface_tool->add_vertex(v0 + grests[parent].basis[j].normalized() * dist * 0.05);
|
|
|
|
if (j == closest)
|
|
continue;
|
|
|
|
Vector3 axis;
|
|
if (first == Vector3()) {
|
|
axis = d.cross(d.cross(grests[parent].basis[j])).normalized();
|
|
first = axis;
|
|
} else {
|
|
axis = d.cross(first).normalized();
|
|
}
|
|
|
|
for (int k = 0; k < 2; k++) {
|
|
|
|
if (k == 1)
|
|
axis = -axis;
|
|
Vector3 point = v0 + d * dist * 0.2;
|
|
point += axis * dist * 0.1;
|
|
|
|
bones.write[0] = parent;
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(bonecolor);
|
|
surface_tool->add_vertex(v0);
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(bonecolor);
|
|
surface_tool->add_vertex(point);
|
|
|
|
bones.write[0] = parent;
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(bonecolor);
|
|
surface_tool->add_vertex(point);
|
|
bones.write[0] = i;
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(bonecolor);
|
|
surface_tool->add_vertex(v1);
|
|
points[pointidx++] = point;
|
|
}
|
|
}
|
|
|
|
SWAP(points[1], points[2]);
|
|
for (int j = 0; j < 4; j++) {
|
|
|
|
bones.write[0] = parent;
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(bonecolor);
|
|
surface_tool->add_vertex(points[j]);
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(bonecolor);
|
|
surface_tool->add_vertex(points[(j + 1) % 4]);
|
|
}
|
|
|
|
/*
|
|
bones[0]=parent;
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(Color(0.4,1,0.4,0.4));
|
|
surface_tool->add_vertex(v0);
|
|
bones[0]=i;
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(Color(0.4,1,0.4,0.4));
|
|
surface_tool->add_vertex(v1);
|
|
*/
|
|
} else {
|
|
|
|
grests.write[i] = skel->get_bone_rest(i);
|
|
bones.write[0] = i;
|
|
}
|
|
/*
|
|
Transform t = grests[i];
|
|
t.orthonormalize();
|
|
|
|
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++) {
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(Color(1.0,0.4,0.4,0.4));
|
|
surface_tool->add_vertex(t.xform(face_points[j]*0.04));
|
|
surface_tool->add_bones(bones);
|
|
surface_tool->add_weights(weights);
|
|
surface_tool->add_color(Color(1.0,0.4,0.4,0.4));
|
|
surface_tool->add_vertex(t.xform(face_points[(j+1)%4]*0.04));
|
|
}
|
|
|
|
}
|
|
*/
|
|
}
|
|
|
|
Ref<ArrayMesh> m = surface_tool->commit();
|
|
p_gizmo->add_mesh(m, false, skel->get_skeleton());
|
|
}
|
|
|
|
////
|
|
|
|
PhysicalBoneSpatialGizmoPlugin::PhysicalBoneSpatialGizmoPlugin() {
|
|
create_material("joint_material", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/joint", Color(0.5, 0.8, 1)));
|
|
}
|
|
|
|
bool PhysicalBoneSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<PhysicalBone>(p_spatial) != NULL;
|
|
}
|
|
|
|
String PhysicalBoneSpatialGizmoPlugin::get_name() const {
|
|
return "PhysicalBones";
|
|
}
|
|
|
|
int PhysicalBoneSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void PhysicalBoneSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
p_gizmo->clear();
|
|
|
|
PhysicalBone *physical_bone = Object::cast_to<PhysicalBone>(p_gizmo->get_spatial_node());
|
|
|
|
if (!physical_bone)
|
|
return;
|
|
|
|
Skeleton *sk(physical_bone->find_skeleton_parent());
|
|
if (!sk)
|
|
return;
|
|
|
|
PhysicalBone *pb(sk->get_physical_bone(physical_bone->get_bone_id()));
|
|
if (!pb)
|
|
return;
|
|
|
|
PhysicalBone *pbp(sk->get_physical_bone_parent(physical_bone->get_bone_id()));
|
|
if (!pbp)
|
|
return;
|
|
|
|
Vector<Vector3> points;
|
|
|
|
switch (physical_bone->get_joint_type()) {
|
|
case PhysicalBone::JOINT_TYPE_PIN: {
|
|
|
|
JointSpatialGizmoPlugin::CreatePinJointGizmo(physical_bone->get_joint_offset(), points);
|
|
} break;
|
|
case PhysicalBone::JOINT_TYPE_CONE: {
|
|
|
|
const PhysicalBone::ConeJointData *cjd(static_cast<const PhysicalBone::ConeJointData *>(physical_bone->get_joint_data()));
|
|
JointSpatialGizmoPlugin::CreateConeTwistJointGizmo(
|
|
physical_bone->get_joint_offset(),
|
|
physical_bone->get_global_transform() * physical_bone->get_joint_offset(),
|
|
pb->get_global_transform(),
|
|
pbp->get_global_transform(),
|
|
cjd->swing_span,
|
|
cjd->twist_span,
|
|
&points,
|
|
&points);
|
|
} break;
|
|
case PhysicalBone::JOINT_TYPE_HINGE: {
|
|
|
|
const PhysicalBone::HingeJointData *hjd(static_cast<const PhysicalBone::HingeJointData *>(physical_bone->get_joint_data()));
|
|
JointSpatialGizmoPlugin::CreateHingeJointGizmo(
|
|
physical_bone->get_joint_offset(),
|
|
physical_bone->get_global_transform() * physical_bone->get_joint_offset(),
|
|
pb->get_global_transform(),
|
|
pbp->get_global_transform(),
|
|
hjd->angular_limit_lower,
|
|
hjd->angular_limit_upper,
|
|
hjd->angular_limit_enabled,
|
|
points,
|
|
&points,
|
|
&points);
|
|
} break;
|
|
case PhysicalBone::JOINT_TYPE_SLIDER: {
|
|
|
|
const PhysicalBone::SliderJointData *sjd(static_cast<const PhysicalBone::SliderJointData *>(physical_bone->get_joint_data()));
|
|
JointSpatialGizmoPlugin::CreateSliderJointGizmo(
|
|
physical_bone->get_joint_offset(),
|
|
physical_bone->get_global_transform() * physical_bone->get_joint_offset(),
|
|
pb->get_global_transform(),
|
|
pbp->get_global_transform(),
|
|
sjd->angular_limit_lower,
|
|
sjd->angular_limit_upper,
|
|
sjd->linear_limit_lower,
|
|
sjd->linear_limit_upper,
|
|
points,
|
|
&points,
|
|
&points);
|
|
} break;
|
|
case PhysicalBone::JOINT_TYPE_6DOF: {
|
|
|
|
const PhysicalBone::SixDOFJointData *sdofjd(static_cast<const PhysicalBone::SixDOFJointData *>(physical_bone->get_joint_data()));
|
|
JointSpatialGizmoPlugin::CreateGeneric6DOFJointGizmo(
|
|
physical_bone->get_joint_offset(),
|
|
|
|
physical_bone->get_global_transform() * physical_bone->get_joint_offset(),
|
|
pb->get_global_transform(),
|
|
pbp->get_global_transform(),
|
|
|
|
sdofjd->axis_data[0].angular_limit_lower,
|
|
sdofjd->axis_data[0].angular_limit_upper,
|
|
sdofjd->axis_data[0].linear_limit_lower,
|
|
sdofjd->axis_data[0].linear_limit_upper,
|
|
sdofjd->axis_data[0].angular_limit_enabled,
|
|
sdofjd->axis_data[0].linear_limit_enabled,
|
|
|
|
sdofjd->axis_data[1].angular_limit_lower,
|
|
sdofjd->axis_data[1].angular_limit_upper,
|
|
sdofjd->axis_data[1].linear_limit_lower,
|
|
sdofjd->axis_data[1].linear_limit_upper,
|
|
sdofjd->axis_data[1].angular_limit_enabled,
|
|
sdofjd->axis_data[1].linear_limit_enabled,
|
|
|
|
sdofjd->axis_data[2].angular_limit_lower,
|
|
sdofjd->axis_data[2].angular_limit_upper,
|
|
sdofjd->axis_data[2].linear_limit_lower,
|
|
sdofjd->axis_data[2].linear_limit_upper,
|
|
sdofjd->axis_data[2].angular_limit_enabled,
|
|
sdofjd->axis_data[2].linear_limit_enabled,
|
|
|
|
points,
|
|
&points,
|
|
&points);
|
|
} break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
Ref<Material> material = get_material("joint_material", p_gizmo);
|
|
|
|
p_gizmo->add_collision_segments(points);
|
|
p_gizmo->add_lines(points, material);
|
|
}
|
|
|
|
// FIXME: Kept as reference for reimplementation in 3.1+
|
|
#if 0
|
|
|
|
void RoomSpatialGizmo::redraw() {
|
|
|
|
clear();
|
|
Ref<RoomBounds> roomie = room->get_room();
|
|
if (roomie.is_null())
|
|
return;
|
|
PoolVector<Face3> faces = roomie->get_geometry_hint();
|
|
|
|
Vector<Vector3> lines;
|
|
int fc = faces.size();
|
|
PoolVector<Face3>::Read r = faces.read();
|
|
|
|
Map<_EdgeKey, Vector3> edge_map;
|
|
|
|
for (int i = 0; i < fc; i++) {
|
|
|
|
Vector3 fn = r[i].get_plane().normal;
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
_EdgeKey ek;
|
|
ek.from = r[i].vertex[j].snapped(Vector3(CMP_EPSILON, CMP_EPSILON, CMP_EPSILON));
|
|
ek.to = r[i].vertex[(j + 1) % 3].snapped(Vector3(CMP_EPSILON, CMP_EPSILON, CMP_EPSILON));
|
|
if (ek.from < ek.to)
|
|
SWAP(ek.from, ek.to);
|
|
|
|
Map<_EdgeKey, Vector3>::Element *E = edge_map.find(ek);
|
|
|
|
if (E) {
|
|
|
|
if (E->get().dot(fn) > 0.9) {
|
|
|
|
E->get() = Vector3();
|
|
}
|
|
|
|
} else {
|
|
|
|
edge_map[ek] = fn;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (Map<_EdgeKey, Vector3>::Element *E = edge_map.front(); E; E = E->next()) {
|
|
|
|
if (E->get() != Vector3()) {
|
|
lines.push_back(E->key().from);
|
|
lines.push_back(E->key().to);
|
|
}
|
|
}
|
|
|
|
add_lines(lines, EditorSpatialGizmos::singleton->room_material);
|
|
add_collision_segments(lines);
|
|
}
|
|
|
|
RoomSpatialGizmo::RoomSpatialGizmo(Room *p_room) {
|
|
|
|
set_spatial_node(p_room);
|
|
room = p_room;
|
|
}
|
|
|
|
/////
|
|
|
|
void PortalSpatialGizmo::redraw() {
|
|
|
|
clear();
|
|
|
|
Vector<Point2> points = portal->get_shape();
|
|
if (points.size() == 0) {
|
|
return;
|
|
}
|
|
|
|
Vector<Vector3> lines;
|
|
|
|
Vector3 center;
|
|
for (int i = 0; i < points.size(); i++) {
|
|
|
|
Vector3 f;
|
|
f.x = points[i].x;
|
|
f.y = points[i].y;
|
|
Vector3 fn;
|
|
fn.x = points[(i + 1) % points.size()].x;
|
|
fn.y = points[(i + 1) % points.size()].y;
|
|
center += f;
|
|
|
|
lines.push_back(f);
|
|
lines.push_back(fn);
|
|
}
|
|
|
|
center /= points.size();
|
|
lines.push_back(center);
|
|
lines.push_back(center + Vector3(0, 0, 1));
|
|
|
|
add_lines(lines, EditorSpatialGizmos::singleton->portal_material);
|
|
add_collision_segments(lines);
|
|
}
|
|
|
|
PortalSpatialGizmo::PortalSpatialGizmo(Portal *p_portal) {
|
|
|
|
set_spatial_node(p_portal);
|
|
portal = p_portal;
|
|
}
|
|
|
|
#endif
|
|
/////
|
|
|
|
RayCastSpatialGizmoPlugin::RayCastSpatialGizmoPlugin() {
|
|
|
|
const Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/shape", Color(0.5, 0.7, 1));
|
|
create_material("shape_material", gizmo_color);
|
|
const float gizmo_value = gizmo_color.get_v();
|
|
const Color gizmo_color_disabled = Color(gizmo_value, gizmo_value, gizmo_value, 0.65);
|
|
create_material("shape_material_disabled", gizmo_color_disabled);
|
|
}
|
|
|
|
bool RayCastSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<RayCast>(p_spatial) != NULL;
|
|
}
|
|
|
|
String RayCastSpatialGizmoPlugin::get_name() const {
|
|
return "RayCast";
|
|
}
|
|
|
|
int RayCastSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void RayCastSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
RayCast *raycast = Object::cast_to<RayCast>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> lines;
|
|
|
|
lines.push_back(Vector3());
|
|
lines.push_back(raycast->get_cast_to());
|
|
|
|
const Ref<SpatialMaterial> material =
|
|
get_material(raycast->is_enabled() ? "shape_material" : "shape_material_disabled", p_gizmo);
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_collision_segments(lines);
|
|
}
|
|
|
|
/////
|
|
|
|
void SpringArmSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
SpringArm *spring_arm = Object::cast_to<SpringArm>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> lines;
|
|
|
|
lines.push_back(Vector3());
|
|
lines.push_back(Vector3(0, 0, 1.0) * spring_arm->get_length());
|
|
|
|
Ref<SpatialMaterial> material = get_material("shape_material", p_gizmo);
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_collision_segments(lines);
|
|
}
|
|
|
|
SpringArmSpatialGizmoPlugin::SpringArmSpatialGizmoPlugin() {
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/shape", Color(0.5, 0.7, 1));
|
|
create_material("shape_material", gizmo_color);
|
|
}
|
|
|
|
bool SpringArmSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<SpringArm>(p_spatial) != NULL;
|
|
}
|
|
|
|
String SpringArmSpatialGizmoPlugin::get_name() const {
|
|
return "SpringArm";
|
|
}
|
|
|
|
int SpringArmSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
/////
|
|
|
|
VehicleWheelSpatialGizmoPlugin::VehicleWheelSpatialGizmoPlugin() {
|
|
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/shape", Color(0.5, 0.7, 1));
|
|
create_material("shape_material", gizmo_color);
|
|
}
|
|
|
|
bool VehicleWheelSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<VehicleWheel>(p_spatial) != NULL;
|
|
}
|
|
|
|
String VehicleWheelSpatialGizmoPlugin::get_name() const {
|
|
return "VehicleWheel";
|
|
}
|
|
|
|
int VehicleWheelSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void VehicleWheelSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
VehicleWheel *car_wheel = Object::cast_to<VehicleWheel>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> points;
|
|
|
|
float r = car_wheel->get_radius();
|
|
const int skip = 10;
|
|
for (int i = 0; i <= 360; i += skip) {
|
|
|
|
float ra = Math::deg2rad((float)i);
|
|
float rb = Math::deg2rad((float)i + skip);
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * r;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * r;
|
|
|
|
points.push_back(Vector3(0, a.x, a.y));
|
|
points.push_back(Vector3(0, b.x, b.y));
|
|
|
|
const int springsec = 4;
|
|
|
|
for (int j = 0; j < springsec; j++) {
|
|
float t = car_wheel->get_suspension_rest_length() * 5;
|
|
points.push_back(Vector3(a.x, i / 360.0 * t / springsec + j * (t / springsec), a.y) * 0.2);
|
|
points.push_back(Vector3(b.x, (i + skip) / 360.0 * t / springsec + j * (t / springsec), b.y) * 0.2);
|
|
}
|
|
}
|
|
|
|
//travel
|
|
points.push_back(Vector3(0, 0, 0));
|
|
points.push_back(Vector3(0, car_wheel->get_suspension_rest_length(), 0));
|
|
|
|
//axis
|
|
points.push_back(Vector3(r * 0.2, car_wheel->get_suspension_rest_length(), 0));
|
|
points.push_back(Vector3(-r * 0.2, car_wheel->get_suspension_rest_length(), 0));
|
|
//axis
|
|
points.push_back(Vector3(r * 0.2, 0, 0));
|
|
points.push_back(Vector3(-r * 0.2, 0, 0));
|
|
|
|
//forward line
|
|
points.push_back(Vector3(0, -r, 0));
|
|
points.push_back(Vector3(0, -r, r * 2));
|
|
points.push_back(Vector3(0, -r, r * 2));
|
|
points.push_back(Vector3(r * 2 * 0.2, -r, r * 2 * 0.8));
|
|
points.push_back(Vector3(0, -r, r * 2));
|
|
points.push_back(Vector3(-r * 2 * 0.2, -r, r * 2 * 0.8));
|
|
|
|
Ref<Material> material = get_material("shape_material", p_gizmo);
|
|
|
|
p_gizmo->add_lines(points, material);
|
|
p_gizmo->add_collision_segments(points);
|
|
}
|
|
|
|
///////////
|
|
|
|
SoftBodySpatialGizmoPlugin::SoftBodySpatialGizmoPlugin() {
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/shape", Color(0.5, 0.7, 1));
|
|
create_material("shape_material", gizmo_color);
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
bool SoftBodySpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<SoftBody>(p_spatial) != NULL;
|
|
}
|
|
|
|
String SoftBodySpatialGizmoPlugin::get_name() const {
|
|
return "SoftBody";
|
|
}
|
|
|
|
int SoftBodySpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
bool SoftBodySpatialGizmoPlugin::is_selectable_when_hidden() const {
|
|
return true;
|
|
}
|
|
|
|
void SoftBodySpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
SoftBody *soft_body = Object::cast_to<SoftBody>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
if (!soft_body || soft_body->get_mesh().is_null()) {
|
|
return;
|
|
}
|
|
|
|
// find mesh
|
|
|
|
Vector<Vector3> lines;
|
|
|
|
soft_body->get_mesh()->generate_debug_mesh_lines(lines);
|
|
|
|
if (!lines.size()) {
|
|
return;
|
|
}
|
|
|
|
Ref<TriangleMesh> tm = soft_body->get_mesh()->generate_triangle_mesh();
|
|
|
|
Vector<Vector3> points;
|
|
soft_body->get_mesh()->generate_debug_mesh_indices(points);
|
|
|
|
Ref<Material> material = get_material("shape_material", p_gizmo);
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_handles(points, get_material("handles"));
|
|
p_gizmo->add_collision_triangles(tm);
|
|
}
|
|
|
|
String SoftBodySpatialGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
return "SoftBody pin point";
|
|
}
|
|
|
|
Variant SoftBodySpatialGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
SoftBody *soft_body = Object::cast_to<SoftBody>(p_gizmo->get_spatial_node());
|
|
return Variant(soft_body->is_point_pinned(p_idx));
|
|
}
|
|
|
|
void SoftBodySpatialGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
SoftBody *soft_body = Object::cast_to<SoftBody>(p_gizmo->get_spatial_node());
|
|
soft_body->pin_point_toggle(p_idx);
|
|
}
|
|
|
|
bool SoftBodySpatialGizmoPlugin::is_handle_highlighted(const EditorSpatialGizmo *p_gizmo, int idx) const {
|
|
SoftBody *soft_body = Object::cast_to<SoftBody>(p_gizmo->get_spatial_node());
|
|
return soft_body->is_point_pinned(idx);
|
|
}
|
|
|
|
///////////
|
|
|
|
VisibilityNotifierGizmoPlugin::VisibilityNotifierGizmoPlugin() {
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/visibility_notifier", Color(0.8, 0.5, 0.7));
|
|
create_material("visibility_notifier_material", gizmo_color);
|
|
gizmo_color.a = 0.1;
|
|
create_material("visibility_notifier_solid_material", gizmo_color);
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
bool VisibilityNotifierGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<VisibilityNotifier>(p_spatial) != NULL;
|
|
}
|
|
|
|
String VisibilityNotifierGizmoPlugin::get_name() const {
|
|
return "VisibilityNotifier";
|
|
}
|
|
|
|
int VisibilityNotifierGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
String VisibilityNotifierGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
switch (p_idx) {
|
|
case 0: return "Size X";
|
|
case 1: return "Size Y";
|
|
case 2: return "Size Z";
|
|
case 3: return "Pos X";
|
|
case 4: return "Pos Y";
|
|
case 5: return "Pos Z";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
Variant VisibilityNotifierGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
VisibilityNotifier *notifier = Object::cast_to<VisibilityNotifier>(p_gizmo->get_spatial_node());
|
|
return notifier->get_aabb();
|
|
}
|
|
void VisibilityNotifierGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
VisibilityNotifier *notifier = Object::cast_to<VisibilityNotifier>(p_gizmo->get_spatial_node());
|
|
|
|
Transform gt = notifier->get_global_transform();
|
|
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
bool move = p_idx >= 3;
|
|
p_idx = p_idx % 3;
|
|
|
|
AABB aabb = notifier->get_aabb();
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 4096) };
|
|
|
|
Vector3 ofs = aabb.position + aabb.size * 0.5;
|
|
|
|
Vector3 axis;
|
|
axis[p_idx] = 1.0;
|
|
|
|
if (move) {
|
|
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(ofs - axis * 4096, ofs + axis * 4096, sg[0], sg[1], ra, rb);
|
|
|
|
float d = ra[p_idx];
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
aabb.position[p_idx] = d - 1.0 - aabb.size[p_idx] * 0.5;
|
|
notifier->set_aabb(aabb);
|
|
|
|
} else {
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(ofs, ofs + axis * 4096, sg[0], sg[1], ra, rb);
|
|
|
|
float d = ra[p_idx] - ofs[p_idx];
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
//resize
|
|
aabb.position[p_idx] = (aabb.position[p_idx] + aabb.size[p_idx] * 0.5) - d;
|
|
aabb.size[p_idx] = d * 2;
|
|
notifier->set_aabb(aabb);
|
|
}
|
|
}
|
|
|
|
void VisibilityNotifierGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
VisibilityNotifier *notifier = Object::cast_to<VisibilityNotifier>(p_gizmo->get_spatial_node());
|
|
|
|
if (p_cancel) {
|
|
notifier->set_aabb(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Notifier AABB"));
|
|
ur->add_do_method(notifier, "set_aabb", notifier->get_aabb());
|
|
ur->add_undo_method(notifier, "set_aabb", p_restore);
|
|
ur->commit_action();
|
|
}
|
|
|
|
void VisibilityNotifierGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
VisibilityNotifier *notifier = Object::cast_to<VisibilityNotifier>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> lines;
|
|
AABB aabb = notifier->get_aabb();
|
|
|
|
for (int i = 0; i < 12; i++) {
|
|
Vector3 a, b;
|
|
aabb.get_edge(i, a, b);
|
|
lines.push_back(a);
|
|
lines.push_back(b);
|
|
}
|
|
|
|
Vector<Vector3> handles;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 ax;
|
|
ax[i] = aabb.position[i] + aabb.size[i];
|
|
ax[(i + 1) % 3] = aabb.position[(i + 1) % 3] + aabb.size[(i + 1) % 3] * 0.5;
|
|
ax[(i + 2) % 3] = aabb.position[(i + 2) % 3] + aabb.size[(i + 2) % 3] * 0.5;
|
|
handles.push_back(ax);
|
|
}
|
|
|
|
Vector3 center = aabb.position + aabb.size * 0.5;
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 ax;
|
|
ax[i] = 1.0;
|
|
handles.push_back(center + ax);
|
|
lines.push_back(center);
|
|
lines.push_back(center + ax);
|
|
}
|
|
|
|
Ref<Material> material = get_material("visibility_notifier_material", p_gizmo);
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_collision_segments(lines);
|
|
|
|
if (p_gizmo->is_selected()) {
|
|
Ref<Material> solid_material = get_material("visibility_notifier_solid_material", p_gizmo);
|
|
p_gizmo->add_solid_box(solid_material, aabb.get_size(), aabb.get_position() + aabb.get_size() / 2.0);
|
|
}
|
|
|
|
p_gizmo->add_handles(handles, get_material("handles"));
|
|
}
|
|
|
|
////
|
|
|
|
CPUParticlesGizmoPlugin::CPUParticlesGizmoPlugin() {
|
|
create_icon_material("particles_icon", SpatialEditor::get_singleton()->get_icon("GizmoCPUParticles", "EditorIcons"));
|
|
}
|
|
|
|
bool CPUParticlesGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<CPUParticles>(p_spatial) != NULL;
|
|
}
|
|
|
|
String CPUParticlesGizmoPlugin::get_name() const {
|
|
return "CPUParticles";
|
|
}
|
|
|
|
int CPUParticlesGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
bool CPUParticlesGizmoPlugin::is_selectable_when_hidden() const {
|
|
return true;
|
|
}
|
|
|
|
void CPUParticlesGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
Ref<Material> icon = get_material("particles_icon", p_gizmo);
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
}
|
|
|
|
////
|
|
|
|
ParticlesGizmoPlugin::ParticlesGizmoPlugin() {
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/particles", Color(0.8, 0.7, 0.4));
|
|
create_material("particles_material", gizmo_color);
|
|
gizmo_color.a = 0.1;
|
|
create_material("particles_solid_material", gizmo_color);
|
|
create_icon_material("particles_icon", SpatialEditor::get_singleton()->get_icon("GizmoParticles", "EditorIcons"));
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
bool ParticlesGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<Particles>(p_spatial) != NULL;
|
|
}
|
|
|
|
String ParticlesGizmoPlugin::get_name() const {
|
|
return "Particles";
|
|
}
|
|
|
|
int ParticlesGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
bool ParticlesGizmoPlugin::is_selectable_when_hidden() const {
|
|
return true;
|
|
}
|
|
|
|
String ParticlesGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
switch (p_idx) {
|
|
case 0: return "Size X";
|
|
case 1: return "Size Y";
|
|
case 2: return "Size Z";
|
|
case 3: return "Pos X";
|
|
case 4: return "Pos Y";
|
|
case 5: return "Pos Z";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
Variant ParticlesGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
Particles *particles = Object::cast_to<Particles>(p_gizmo->get_spatial_node());
|
|
return particles->get_visibility_aabb();
|
|
}
|
|
void ParticlesGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
Particles *particles = Object::cast_to<Particles>(p_gizmo->get_spatial_node());
|
|
|
|
Transform gt = particles->get_global_transform();
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
bool move = p_idx >= 3;
|
|
p_idx = p_idx % 3;
|
|
|
|
AABB aabb = particles->get_visibility_aabb();
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 4096) };
|
|
|
|
Vector3 ofs = aabb.position + aabb.size * 0.5;
|
|
|
|
Vector3 axis;
|
|
axis[p_idx] = 1.0;
|
|
|
|
if (move) {
|
|
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(ofs - axis * 4096, ofs + axis * 4096, sg[0], sg[1], ra, rb);
|
|
|
|
float d = ra[p_idx];
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
aabb.position[p_idx] = d - 1.0 - aabb.size[p_idx] * 0.5;
|
|
particles->set_visibility_aabb(aabb);
|
|
|
|
} else {
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(ofs, ofs + axis * 4096, sg[0], sg[1], ra, rb);
|
|
|
|
float d = ra[p_idx] - ofs[p_idx];
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
//resize
|
|
aabb.position[p_idx] = (aabb.position[p_idx] + aabb.size[p_idx] * 0.5) - d;
|
|
aabb.size[p_idx] = d * 2;
|
|
particles->set_visibility_aabb(aabb);
|
|
}
|
|
}
|
|
|
|
void ParticlesGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
Particles *particles = Object::cast_to<Particles>(p_gizmo->get_spatial_node());
|
|
|
|
if (p_cancel) {
|
|
particles->set_visibility_aabb(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Particles AABB"));
|
|
ur->add_do_method(particles, "set_visibility_aabb", particles->get_visibility_aabb());
|
|
ur->add_undo_method(particles, "set_visibility_aabb", p_restore);
|
|
ur->commit_action();
|
|
}
|
|
|
|
void ParticlesGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
Particles *particles = Object::cast_to<Particles>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> lines;
|
|
AABB aabb = particles->get_visibility_aabb();
|
|
|
|
for (int i = 0; i < 12; i++) {
|
|
Vector3 a, b;
|
|
aabb.get_edge(i, a, b);
|
|
lines.push_back(a);
|
|
lines.push_back(b);
|
|
}
|
|
|
|
Vector<Vector3> handles;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 ax;
|
|
ax[i] = aabb.position[i] + aabb.size[i];
|
|
ax[(i + 1) % 3] = aabb.position[(i + 1) % 3] + aabb.size[(i + 1) % 3] * 0.5;
|
|
ax[(i + 2) % 3] = aabb.position[(i + 2) % 3] + aabb.size[(i + 2) % 3] * 0.5;
|
|
handles.push_back(ax);
|
|
}
|
|
|
|
Vector3 center = aabb.position + aabb.size * 0.5;
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 ax;
|
|
ax[i] = 1.0;
|
|
handles.push_back(center + ax);
|
|
lines.push_back(center);
|
|
lines.push_back(center + ax);
|
|
}
|
|
|
|
Ref<Material> material = get_material("particles_material", p_gizmo);
|
|
Ref<Material> icon = get_material("particles_icon", p_gizmo);
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
|
|
if (p_gizmo->is_selected()) {
|
|
Ref<Material> solid_material = get_material("particles_solid_material", p_gizmo);
|
|
p_gizmo->add_solid_box(solid_material, aabb.get_size(), aabb.get_position() + aabb.get_size() / 2.0);
|
|
}
|
|
|
|
p_gizmo->add_handles(handles, get_material("handles"));
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
}
|
|
////
|
|
|
|
ReflectionProbeGizmoPlugin::ReflectionProbeGizmoPlugin() {
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/reflection_probe", Color(0.6, 1, 0.5));
|
|
|
|
create_material("reflection_probe_material", gizmo_color);
|
|
|
|
gizmo_color.a = 0.5;
|
|
create_material("reflection_internal_material", gizmo_color);
|
|
|
|
gizmo_color.a = 0.1;
|
|
create_material("reflection_probe_solid_material", gizmo_color);
|
|
|
|
create_icon_material("reflection_probe_icon", SpatialEditor::get_singleton()->get_icon("GizmoReflectionProbe", "EditorIcons"));
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
bool ReflectionProbeGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<ReflectionProbe>(p_spatial) != NULL;
|
|
}
|
|
|
|
String ReflectionProbeGizmoPlugin::get_name() const {
|
|
return "ReflectionProbe";
|
|
}
|
|
|
|
int ReflectionProbeGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
String ReflectionProbeGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
switch (p_idx) {
|
|
case 0: return "Extents X";
|
|
case 1: return "Extents Y";
|
|
case 2: return "Extents Z";
|
|
case 3: return "Origin X";
|
|
case 4: return "Origin Y";
|
|
case 5: return "Origin Z";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
Variant ReflectionProbeGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
ReflectionProbe *probe = Object::cast_to<ReflectionProbe>(p_gizmo->get_spatial_node());
|
|
return AABB(probe->get_extents(), probe->get_origin_offset());
|
|
}
|
|
void ReflectionProbeGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
ReflectionProbe *probe = Object::cast_to<ReflectionProbe>(p_gizmo->get_spatial_node());
|
|
Transform gt = probe->get_global_transform();
|
|
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
if (p_idx < 3) {
|
|
Vector3 extents = probe->get_extents();
|
|
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 16384) };
|
|
|
|
Vector3 axis;
|
|
axis[p_idx] = 1.0;
|
|
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), axis * 16384, sg[0], sg[1], ra, rb);
|
|
float d = ra[p_idx];
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
|
|
extents[p_idx] = d;
|
|
probe->set_extents(extents);
|
|
} else {
|
|
|
|
p_idx -= 3;
|
|
|
|
Vector3 origin = probe->get_origin_offset();
|
|
origin[p_idx] = 0;
|
|
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 16384) };
|
|
|
|
Vector3 axis;
|
|
axis[p_idx] = 1.0;
|
|
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(origin - axis * 16384, origin + axis * 16384, sg[0], sg[1], ra, rb);
|
|
// Adjust the actual position to account for the gizmo handle position
|
|
float d = ra[p_idx] + 0.25;
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
origin[p_idx] = d;
|
|
probe->set_origin_offset(origin);
|
|
}
|
|
}
|
|
|
|
void ReflectionProbeGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
ReflectionProbe *probe = Object::cast_to<ReflectionProbe>(p_gizmo->get_spatial_node());
|
|
|
|
AABB restore = p_restore;
|
|
|
|
if (p_cancel) {
|
|
probe->set_extents(restore.position);
|
|
probe->set_origin_offset(restore.size);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Probe Extents"));
|
|
ur->add_do_method(probe, "set_extents", probe->get_extents());
|
|
ur->add_do_method(probe, "set_origin_offset", probe->get_origin_offset());
|
|
ur->add_undo_method(probe, "set_extents", restore.position);
|
|
ur->add_undo_method(probe, "set_origin_offset", restore.size);
|
|
ur->commit_action();
|
|
}
|
|
|
|
void ReflectionProbeGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
ReflectionProbe *probe = Object::cast_to<ReflectionProbe>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> lines;
|
|
Vector<Vector3> internal_lines;
|
|
Vector3 extents = probe->get_extents();
|
|
|
|
AABB aabb;
|
|
aabb.position = -extents;
|
|
aabb.size = extents * 2;
|
|
|
|
for (int i = 0; i < 12; i++) {
|
|
Vector3 a, b;
|
|
aabb.get_edge(i, a, b);
|
|
lines.push_back(a);
|
|
lines.push_back(b);
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
Vector3 ep = aabb.get_endpoint(i);
|
|
internal_lines.push_back(probe->get_origin_offset());
|
|
internal_lines.push_back(ep);
|
|
}
|
|
|
|
Vector<Vector3> handles;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 ax;
|
|
ax[i] = aabb.position[i] + aabb.size[i];
|
|
handles.push_back(ax);
|
|
}
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 orig_handle = probe->get_origin_offset();
|
|
orig_handle[i] -= 0.25;
|
|
lines.push_back(orig_handle);
|
|
handles.push_back(orig_handle);
|
|
|
|
orig_handle[i] += 0.5;
|
|
lines.push_back(orig_handle);
|
|
}
|
|
|
|
Ref<Material> material = get_material("reflection_probe_material", p_gizmo);
|
|
Ref<Material> material_internal = get_material("reflection_internal_material", p_gizmo);
|
|
Ref<Material> icon = get_material("reflection_probe_icon", p_gizmo);
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_lines(internal_lines, material_internal);
|
|
|
|
if (p_gizmo->is_selected()) {
|
|
Ref<Material> solid_material = get_material("reflection_probe_solid_material", p_gizmo);
|
|
p_gizmo->add_solid_box(solid_material, probe->get_extents() * 2.0);
|
|
}
|
|
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
p_gizmo->add_handles(handles, get_material("handles"));
|
|
}
|
|
|
|
GIProbeGizmoPlugin::GIProbeGizmoPlugin() {
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/gi_probe", Color(0.5, 1, 0.6));
|
|
|
|
create_material("gi_probe_material", gizmo_color);
|
|
|
|
gizmo_color.a = 0.5;
|
|
create_material("gi_probe_internal_material", gizmo_color);
|
|
|
|
gizmo_color.a = 0.1;
|
|
create_material("gi_probe_solid_material", gizmo_color);
|
|
|
|
create_icon_material("gi_probe_icon", SpatialEditor::get_singleton()->get_icon("GizmoGIProbe", "EditorIcons"));
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
bool GIProbeGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<GIProbe>(p_spatial) != NULL;
|
|
}
|
|
|
|
String GIProbeGizmoPlugin::get_name() const {
|
|
return "GIProbe";
|
|
}
|
|
|
|
int GIProbeGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
String GIProbeGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
switch (p_idx) {
|
|
case 0: return "Extents X";
|
|
case 1: return "Extents Y";
|
|
case 2: return "Extents Z";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
Variant GIProbeGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
GIProbe *probe = Object::cast_to<GIProbe>(p_gizmo->get_spatial_node());
|
|
return probe->get_extents();
|
|
}
|
|
void GIProbeGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
GIProbe *probe = Object::cast_to<GIProbe>(p_gizmo->get_spatial_node());
|
|
|
|
Transform gt = probe->get_global_transform();
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
Vector3 extents = probe->get_extents();
|
|
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 16384) };
|
|
|
|
Vector3 axis;
|
|
axis[p_idx] = 1.0;
|
|
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), axis * 16384, sg[0], sg[1], ra, rb);
|
|
float d = ra[p_idx];
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
|
|
extents[p_idx] = d;
|
|
probe->set_extents(extents);
|
|
}
|
|
|
|
void GIProbeGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
GIProbe *probe = Object::cast_to<GIProbe>(p_gizmo->get_spatial_node());
|
|
|
|
Vector3 restore = p_restore;
|
|
|
|
if (p_cancel) {
|
|
probe->set_extents(restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Probe Extents"));
|
|
ur->add_do_method(probe, "set_extents", probe->get_extents());
|
|
ur->add_undo_method(probe, "set_extents", restore);
|
|
ur->commit_action();
|
|
}
|
|
|
|
void GIProbeGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
GIProbe *probe = Object::cast_to<GIProbe>(p_gizmo->get_spatial_node());
|
|
|
|
Ref<Material> material = get_material("gi_probe_material", p_gizmo);
|
|
Ref<Material> icon = get_material("gi_probe_icon", p_gizmo);
|
|
Ref<Material> material_internal = get_material("gi_probe_internal_material", p_gizmo);
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> lines;
|
|
Vector3 extents = probe->get_extents();
|
|
|
|
static const int subdivs[GIProbe::SUBDIV_MAX] = { 64, 128, 256, 512 };
|
|
|
|
AABB aabb = AABB(-extents, extents * 2);
|
|
int subdiv = subdivs[probe->get_subdiv()];
|
|
float cell_size = aabb.get_longest_axis_size() / subdiv;
|
|
|
|
for (int i = 0; i < 12; i++) {
|
|
Vector3 a, b;
|
|
aabb.get_edge(i, a, b);
|
|
lines.push_back(a);
|
|
lines.push_back(b);
|
|
}
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
|
|
lines.clear();
|
|
|
|
for (int i = 1; i < subdiv; i++) {
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
if (cell_size * i > aabb.size[j]) {
|
|
continue;
|
|
}
|
|
|
|
Vector2 dir;
|
|
dir[j] = 1.0;
|
|
Vector2 ta, tb;
|
|
int j_n1 = (j + 1) % 3;
|
|
int j_n2 = (j + 2) % 3;
|
|
ta[j_n1] = 1.0;
|
|
tb[j_n2] = 1.0;
|
|
|
|
for (int k = 0; k < 4; k++) {
|
|
|
|
Vector3 from = aabb.position, to = aabb.position;
|
|
from[j] += cell_size * i;
|
|
to[j] += cell_size * i;
|
|
|
|
if (k & 1) {
|
|
to[j_n1] += aabb.size[j_n1];
|
|
} else {
|
|
|
|
to[j_n2] += aabb.size[j_n2];
|
|
}
|
|
|
|
if (k & 2) {
|
|
from[j_n1] += aabb.size[j_n1];
|
|
from[j_n2] += aabb.size[j_n2];
|
|
}
|
|
|
|
lines.push_back(from);
|
|
lines.push_back(to);
|
|
}
|
|
}
|
|
}
|
|
|
|
p_gizmo->add_lines(lines, material_internal);
|
|
|
|
Vector<Vector3> handles;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 ax;
|
|
ax[i] = aabb.position[i] + aabb.size[i];
|
|
handles.push_back(ax);
|
|
}
|
|
|
|
if (p_gizmo->is_selected()) {
|
|
Ref<Material> solid_material = get_material("gi_probe_solid_material", p_gizmo);
|
|
p_gizmo->add_solid_box(solid_material, aabb.get_size());
|
|
}
|
|
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
p_gizmo->add_handles(handles, get_material("handles"));
|
|
}
|
|
|
|
////
|
|
|
|
BakedIndirectLightGizmoPlugin::BakedIndirectLightGizmoPlugin() {
|
|
Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/baked_indirect_light", Color(0.5, 0.6, 1));
|
|
|
|
create_material("baked_indirect_light_material", gizmo_color);
|
|
|
|
gizmo_color.a = 0.1;
|
|
create_material("baked_indirect_light_internal_material", gizmo_color);
|
|
|
|
create_icon_material("baked_indirect_light_icon", SpatialEditor::get_singleton()->get_icon("GizmoBakedLightmap", "EditorIcons"));
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
String BakedIndirectLightGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
switch (p_idx) {
|
|
case 0: return "Extents X";
|
|
case 1: return "Extents Y";
|
|
case 2: return "Extents Z";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
Variant BakedIndirectLightGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
BakedLightmap *baker = Object::cast_to<BakedLightmap>(p_gizmo->get_spatial_node());
|
|
return baker->get_extents();
|
|
}
|
|
void BakedIndirectLightGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
BakedLightmap *baker = Object::cast_to<BakedLightmap>(p_gizmo->get_spatial_node());
|
|
|
|
Transform gt = baker->get_global_transform();
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
Vector3 extents = baker->get_extents();
|
|
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 16384) };
|
|
|
|
Vector3 axis;
|
|
axis[p_idx] = 1.0;
|
|
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), axis * 16384, sg[0], sg[1], ra, rb);
|
|
float d = ra[p_idx];
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
|
|
extents[p_idx] = d;
|
|
baker->set_extents(extents);
|
|
}
|
|
|
|
void BakedIndirectLightGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
BakedLightmap *baker = Object::cast_to<BakedLightmap>(p_gizmo->get_spatial_node());
|
|
|
|
Vector3 restore = p_restore;
|
|
|
|
if (p_cancel) {
|
|
baker->set_extents(restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Probe Extents"));
|
|
ur->add_do_method(baker, "set_extents", baker->get_extents());
|
|
ur->add_undo_method(baker, "set_extents", restore);
|
|
ur->commit_action();
|
|
}
|
|
|
|
bool BakedIndirectLightGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<BakedLightmap>(p_spatial) != NULL;
|
|
}
|
|
|
|
String BakedIndirectLightGizmoPlugin::get_name() const {
|
|
return "BakedLightmap";
|
|
}
|
|
|
|
int BakedIndirectLightGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void BakedIndirectLightGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
BakedLightmap *baker = Object::cast_to<BakedLightmap>(p_gizmo->get_spatial_node());
|
|
|
|
Ref<Material> material = get_material("baked_indirect_light_material", p_gizmo);
|
|
Ref<Material> icon = get_material("baked_indirect_light_icon", p_gizmo);
|
|
Ref<Material> material_internal = get_material("baked_indirect_light_internal_material", p_gizmo);
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector3> lines;
|
|
Vector3 extents = baker->get_extents();
|
|
|
|
AABB aabb = AABB(-extents, extents * 2);
|
|
|
|
for (int i = 0; i < 12; i++) {
|
|
Vector3 a, b;
|
|
aabb.get_edge(i, a, b);
|
|
lines.push_back(a);
|
|
lines.push_back(b);
|
|
}
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
|
|
Vector<Vector3> handles;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 ax;
|
|
ax[i] = aabb.position[i] + aabb.size[i];
|
|
handles.push_back(ax);
|
|
}
|
|
|
|
if (p_gizmo->is_selected()) {
|
|
p_gizmo->add_solid_box(material_internal, aabb.get_size());
|
|
}
|
|
|
|
p_gizmo->add_unscaled_billboard(icon, 0.05);
|
|
p_gizmo->add_handles(handles, get_material("handles"));
|
|
}
|
|
|
|
////
|
|
|
|
CollisionShapeSpatialGizmoPlugin::CollisionShapeSpatialGizmoPlugin() {
|
|
const Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/shape", Color(0.5, 0.7, 1));
|
|
create_material("shape_material", gizmo_color);
|
|
const float gizmo_value = gizmo_color.get_v();
|
|
const Color gizmo_color_disabled = Color(gizmo_value, gizmo_value, gizmo_value, 0.65);
|
|
create_material("shape_material_disabled", gizmo_color_disabled);
|
|
create_handle_material("handles");
|
|
}
|
|
|
|
bool CollisionShapeSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<CollisionShape>(p_spatial) != NULL;
|
|
}
|
|
|
|
String CollisionShapeSpatialGizmoPlugin::get_name() const {
|
|
return "CollisionShape";
|
|
}
|
|
|
|
int CollisionShapeSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
String CollisionShapeSpatialGizmoPlugin::get_handle_name(const EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
const CollisionShape *cs = Object::cast_to<CollisionShape>(p_gizmo->get_spatial_node());
|
|
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return "";
|
|
|
|
if (Object::cast_to<SphereShape>(*s)) {
|
|
|
|
return "Radius";
|
|
}
|
|
|
|
if (Object::cast_to<BoxShape>(*s)) {
|
|
|
|
return "Extents";
|
|
}
|
|
|
|
if (Object::cast_to<CapsuleShape>(*s)) {
|
|
|
|
return p_idx == 0 ? "Radius" : "Height";
|
|
}
|
|
|
|
if (Object::cast_to<CylinderShape>(*s)) {
|
|
|
|
return p_idx == 0 ? "Radius" : "Height";
|
|
}
|
|
|
|
if (Object::cast_to<RayShape>(*s)) {
|
|
|
|
return "Length";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
Variant CollisionShapeSpatialGizmoPlugin::get_handle_value(EditorSpatialGizmo *p_gizmo, int p_idx) const {
|
|
|
|
CollisionShape *cs = Object::cast_to<CollisionShape>(p_gizmo->get_spatial_node());
|
|
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return Variant();
|
|
|
|
if (Object::cast_to<SphereShape>(*s)) {
|
|
|
|
Ref<SphereShape> ss = s;
|
|
return ss->get_radius();
|
|
}
|
|
|
|
if (Object::cast_to<BoxShape>(*s)) {
|
|
|
|
Ref<BoxShape> bs = s;
|
|
return bs->get_extents();
|
|
}
|
|
|
|
if (Object::cast_to<CapsuleShape>(*s)) {
|
|
|
|
Ref<CapsuleShape> cs2 = s;
|
|
return p_idx == 0 ? cs2->get_radius() : cs2->get_height();
|
|
}
|
|
|
|
if (Object::cast_to<CylinderShape>(*s)) {
|
|
|
|
Ref<CylinderShape> cs2 = s;
|
|
return p_idx == 0 ? cs2->get_radius() : cs2->get_height();
|
|
}
|
|
|
|
if (Object::cast_to<RayShape>(*s)) {
|
|
|
|
Ref<RayShape> cs2 = s;
|
|
return cs2->get_length();
|
|
}
|
|
|
|
return Variant();
|
|
}
|
|
void CollisionShapeSpatialGizmoPlugin::set_handle(EditorSpatialGizmo *p_gizmo, int p_idx, Camera *p_camera, const Point2 &p_point) {
|
|
|
|
CollisionShape *cs = Object::cast_to<CollisionShape>(p_gizmo->get_spatial_node());
|
|
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return;
|
|
|
|
Transform gt = cs->get_global_transform();
|
|
gt.orthonormalize();
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
Vector3 ray_from = p_camera->project_ray_origin(p_point);
|
|
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
|
|
|
|
Vector3 sg[2] = { gi.xform(ray_from), gi.xform(ray_from + ray_dir * 4096) };
|
|
|
|
if (Object::cast_to<SphereShape>(*s)) {
|
|
|
|
Ref<SphereShape> ss = s;
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), Vector3(4096, 0, 0), sg[0], sg[1], ra, rb);
|
|
float d = ra.x;
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
|
|
ss->set_radius(d);
|
|
}
|
|
|
|
if (Object::cast_to<RayShape>(*s)) {
|
|
|
|
Ref<RayShape> rs = s;
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), Vector3(0, 0, 4096), sg[0], sg[1], ra, rb);
|
|
float d = ra.z;
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
|
|
rs->set_length(d);
|
|
}
|
|
|
|
if (Object::cast_to<BoxShape>(*s)) {
|
|
|
|
Vector3 axis;
|
|
axis[p_idx] = 1.0;
|
|
Ref<BoxShape> bs = s;
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), axis * 4096, sg[0], sg[1], ra, rb);
|
|
float d = ra[p_idx];
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
|
|
Vector3 he = bs->get_extents();
|
|
he[p_idx] = d;
|
|
bs->set_extents(he);
|
|
}
|
|
|
|
if (Object::cast_to<CapsuleShape>(*s)) {
|
|
|
|
Vector3 axis;
|
|
axis[p_idx == 0 ? 0 : 2] = 1.0;
|
|
Ref<CapsuleShape> cs2 = s;
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), axis * 4096, sg[0], sg[1], ra, rb);
|
|
float d = axis.dot(ra);
|
|
if (p_idx == 1)
|
|
d -= cs2->get_radius();
|
|
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
|
|
if (p_idx == 0)
|
|
cs2->set_radius(d);
|
|
else if (p_idx == 1)
|
|
cs2->set_height(d * 2.0);
|
|
}
|
|
|
|
if (Object::cast_to<CylinderShape>(*s)) {
|
|
|
|
Vector3 axis;
|
|
axis[p_idx == 0 ? 0 : 1] = 1.0;
|
|
Ref<CylinderShape> cs2 = s;
|
|
Vector3 ra, rb;
|
|
Geometry::get_closest_points_between_segments(Vector3(), axis * 4096, sg[0], sg[1], ra, rb);
|
|
float d = axis.dot(ra);
|
|
if (SpatialEditor::get_singleton()->is_snap_enabled()) {
|
|
d = Math::stepify(d, SpatialEditor::get_singleton()->get_translate_snap());
|
|
}
|
|
|
|
if (d < 0.001)
|
|
d = 0.001;
|
|
|
|
if (p_idx == 0)
|
|
cs2->set_radius(d);
|
|
else if (p_idx == 1)
|
|
cs2->set_height(d * 2.0);
|
|
}
|
|
}
|
|
void CollisionShapeSpatialGizmoPlugin::commit_handle(EditorSpatialGizmo *p_gizmo, int p_idx, const Variant &p_restore, bool p_cancel) {
|
|
|
|
CollisionShape *cs = Object::cast_to<CollisionShape>(p_gizmo->get_spatial_node());
|
|
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return;
|
|
|
|
if (Object::cast_to<SphereShape>(*s)) {
|
|
|
|
Ref<SphereShape> ss = s;
|
|
if (p_cancel) {
|
|
ss->set_radius(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Sphere Shape Radius"));
|
|
ur->add_do_method(ss.ptr(), "set_radius", ss->get_radius());
|
|
ur->add_undo_method(ss.ptr(), "set_radius", p_restore);
|
|
ur->commit_action();
|
|
}
|
|
|
|
if (Object::cast_to<BoxShape>(*s)) {
|
|
|
|
Ref<BoxShape> ss = s;
|
|
if (p_cancel) {
|
|
ss->set_extents(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Box Shape Extents"));
|
|
ur->add_do_method(ss.ptr(), "set_extents", ss->get_extents());
|
|
ur->add_undo_method(ss.ptr(), "set_extents", p_restore);
|
|
ur->commit_action();
|
|
}
|
|
|
|
if (Object::cast_to<CapsuleShape>(*s)) {
|
|
|
|
Ref<CapsuleShape> ss = s;
|
|
if (p_cancel) {
|
|
if (p_idx == 0)
|
|
ss->set_radius(p_restore);
|
|
else
|
|
ss->set_height(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
if (p_idx == 0) {
|
|
ur->create_action(TTR("Change Capsule Shape Radius"));
|
|
ur->add_do_method(ss.ptr(), "set_radius", ss->get_radius());
|
|
ur->add_undo_method(ss.ptr(), "set_radius", p_restore);
|
|
} else {
|
|
ur->create_action(TTR("Change Capsule Shape Height"));
|
|
ur->add_do_method(ss.ptr(), "set_height", ss->get_height());
|
|
ur->add_undo_method(ss.ptr(), "set_height", p_restore);
|
|
}
|
|
|
|
ur->commit_action();
|
|
}
|
|
|
|
if (Object::cast_to<CylinderShape>(*s)) {
|
|
|
|
Ref<CylinderShape> ss = s;
|
|
if (p_cancel) {
|
|
if (p_idx == 0)
|
|
ss->set_radius(p_restore);
|
|
else
|
|
ss->set_height(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
if (p_idx == 0) {
|
|
ur->create_action(TTR("Change Cylinder Shape Radius"));
|
|
ur->add_do_method(ss.ptr(), "set_radius", ss->get_radius());
|
|
ur->add_undo_method(ss.ptr(), "set_radius", p_restore);
|
|
} else {
|
|
ur->create_action(
|
|
///
|
|
|
|
////////
|
|
TTR("Change Cylinder Shape Height"));
|
|
ur->add_do_method(ss.ptr(), "set_height", ss->get_height());
|
|
ur->add_undo_method(ss.ptr(), "set_height", p_restore);
|
|
}
|
|
|
|
ur->commit_action();
|
|
}
|
|
|
|
if (Object::cast_to<RayShape>(*s)) {
|
|
|
|
Ref<RayShape> ss = s;
|
|
if (p_cancel) {
|
|
ss->set_length(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Ray Shape Length"));
|
|
ur->add_do_method(ss.ptr(), "set_length", ss->get_length());
|
|
ur->add_undo_method(ss.ptr(), "set_length", p_restore);
|
|
ur->commit_action();
|
|
}
|
|
}
|
|
void CollisionShapeSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
CollisionShape *cs = Object::cast_to<CollisionShape>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return;
|
|
|
|
const Ref<Material> material =
|
|
get_material(!cs->is_disabled() ? "shape_material" : "shape_material_disabled", p_gizmo);
|
|
Ref<Material> handles_material = get_material("handles");
|
|
|
|
if (Object::cast_to<SphereShape>(*s)) {
|
|
|
|
Ref<SphereShape> sp = s;
|
|
float r = sp->get_radius();
|
|
|
|
Vector<Vector3> points;
|
|
|
|
for (int i = 0; i <= 360; i++) {
|
|
|
|
float ra = Math::deg2rad((float)i);
|
|
float rb = Math::deg2rad((float)i + 1);
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * r;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * r;
|
|
|
|
points.push_back(Vector3(a.x, 0, a.y));
|
|
points.push_back(Vector3(b.x, 0, b.y));
|
|
points.push_back(Vector3(0, a.x, a.y));
|
|
points.push_back(Vector3(0, b.x, b.y));
|
|
points.push_back(Vector3(a.x, a.y, 0));
|
|
points.push_back(Vector3(b.x, b.y, 0));
|
|
}
|
|
|
|
Vector<Vector3> collision_segments;
|
|
|
|
for (int i = 0; i < 64; i++) {
|
|
|
|
float ra = i * Math_PI * 2.0 / 64.0;
|
|
float rb = (i + 1) * Math_PI * 2.0 / 64.0;
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * r;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * r;
|
|
|
|
collision_segments.push_back(Vector3(a.x, 0, a.y));
|
|
collision_segments.push_back(Vector3(b.x, 0, b.y));
|
|
collision_segments.push_back(Vector3(0, a.x, a.y));
|
|
collision_segments.push_back(Vector3(0, b.x, b.y));
|
|
collision_segments.push_back(Vector3(a.x, a.y, 0));
|
|
collision_segments.push_back(Vector3(b.x, b.y, 0));
|
|
}
|
|
|
|
p_gizmo->add_lines(points, material);
|
|
p_gizmo->add_collision_segments(collision_segments);
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(r, 0, 0));
|
|
p_gizmo->add_handles(handles, handles_material);
|
|
}
|
|
|
|
if (Object::cast_to<BoxShape>(*s)) {
|
|
|
|
Ref<BoxShape> bs = s;
|
|
Vector<Vector3> lines;
|
|
AABB aabb;
|
|
aabb.position = -bs->get_extents();
|
|
aabb.size = aabb.position * -2;
|
|
|
|
for (int i = 0; i < 12; i++) {
|
|
Vector3 a, b;
|
|
aabb.get_edge(i, a, b);
|
|
lines.push_back(a);
|
|
lines.push_back(b);
|
|
}
|
|
|
|
Vector<Vector3> handles;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
Vector3 ax;
|
|
ax[i] = bs->get_extents()[i];
|
|
handles.push_back(ax);
|
|
}
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_collision_segments(lines);
|
|
p_gizmo->add_handles(handles, handles_material);
|
|
}
|
|
|
|
if (Object::cast_to<CapsuleShape>(*s)) {
|
|
|
|
Ref<CapsuleShape> cs2 = s;
|
|
float radius = cs2->get_radius();
|
|
float height = cs2->get_height();
|
|
|
|
Vector<Vector3> points;
|
|
|
|
Vector3 d(0, 0, height * 0.5);
|
|
for (int i = 0; i < 360; i++) {
|
|
|
|
float ra = Math::deg2rad((float)i);
|
|
float rb = Math::deg2rad((float)i + 1);
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * radius;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * radius;
|
|
|
|
points.push_back(Vector3(a.x, a.y, 0) + d);
|
|
points.push_back(Vector3(b.x, b.y, 0) + d);
|
|
|
|
points.push_back(Vector3(a.x, a.y, 0) - d);
|
|
points.push_back(Vector3(b.x, b.y, 0) - d);
|
|
|
|
if (i % 90 == 0) {
|
|
|
|
points.push_back(Vector3(a.x, a.y, 0) + d);
|
|
points.push_back(Vector3(a.x, a.y, 0) - d);
|
|
}
|
|
|
|
Vector3 dud = i < 180 ? d : -d;
|
|
|
|
points.push_back(Vector3(0, a.y, a.x) + dud);
|
|
points.push_back(Vector3(0, b.y, b.x) + dud);
|
|
points.push_back(Vector3(a.y, 0, a.x) + dud);
|
|
points.push_back(Vector3(b.y, 0, b.x) + dud);
|
|
}
|
|
|
|
p_gizmo->add_lines(points, material);
|
|
|
|
Vector<Vector3> collision_segments;
|
|
|
|
for (int i = 0; i < 64; i++) {
|
|
|
|
float ra = i * Math_PI * 2.0 / 64.0;
|
|
float rb = (i + 1) * Math_PI * 2.0 / 64.0;
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * radius;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * radius;
|
|
|
|
collision_segments.push_back(Vector3(a.x, a.y, 0) + d);
|
|
collision_segments.push_back(Vector3(b.x, b.y, 0) + d);
|
|
|
|
collision_segments.push_back(Vector3(a.x, a.y, 0) - d);
|
|
collision_segments.push_back(Vector3(b.x, b.y, 0) - d);
|
|
|
|
if (i % 16 == 0) {
|
|
|
|
collision_segments.push_back(Vector3(a.x, a.y, 0) + d);
|
|
collision_segments.push_back(Vector3(a.x, a.y, 0) - d);
|
|
}
|
|
|
|
Vector3 dud = i < 32 ? d : -d;
|
|
|
|
collision_segments.push_back(Vector3(0, a.y, a.x) + dud);
|
|
collision_segments.push_back(Vector3(0, b.y, b.x) + dud);
|
|
collision_segments.push_back(Vector3(a.y, 0, a.x) + dud);
|
|
collision_segments.push_back(Vector3(b.y, 0, b.x) + dud);
|
|
}
|
|
|
|
p_gizmo->add_collision_segments(collision_segments);
|
|
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(cs2->get_radius(), 0, 0));
|
|
handles.push_back(Vector3(0, 0, cs2->get_height() * 0.5 + cs2->get_radius()));
|
|
p_gizmo->add_handles(handles, handles_material);
|
|
}
|
|
|
|
if (Object::cast_to<CylinderShape>(*s)) {
|
|
|
|
Ref<CylinderShape> cs2 = s;
|
|
float radius = cs2->get_radius();
|
|
float height = cs2->get_height();
|
|
|
|
Vector<Vector3> points;
|
|
|
|
Vector3 d(0, height * 0.5, 0);
|
|
for (int i = 0; i < 360; i++) {
|
|
|
|
float ra = Math::deg2rad((float)i);
|
|
float rb = Math::deg2rad((float)i + 1);
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * radius;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * radius;
|
|
|
|
points.push_back(Vector3(a.x, 0, a.y) + d);
|
|
points.push_back(Vector3(b.x, 0, b.y) + d);
|
|
|
|
points.push_back(Vector3(a.x, 0, a.y) - d);
|
|
points.push_back(Vector3(b.x, 0, b.y) - d);
|
|
|
|
if (i % 90 == 0) {
|
|
|
|
points.push_back(Vector3(a.x, 0, a.y) + d);
|
|
points.push_back(Vector3(a.x, 0, a.y) - d);
|
|
}
|
|
}
|
|
|
|
p_gizmo->add_lines(points, material);
|
|
|
|
Vector<Vector3> collision_segments;
|
|
|
|
for (int i = 0; i < 64; i++) {
|
|
|
|
float ra = i * Math_PI * 2.0 / 64.0;
|
|
float rb = (i + 1) * Math_PI * 2.0 / 64.0;
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * radius;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * radius;
|
|
|
|
collision_segments.push_back(Vector3(a.x, 0, a.y) + d);
|
|
collision_segments.push_back(Vector3(b.x, 0, b.y) + d);
|
|
|
|
collision_segments.push_back(Vector3(a.x, 0, a.y) - d);
|
|
collision_segments.push_back(Vector3(b.x, 0, b.y) - d);
|
|
|
|
if (i % 16 == 0) {
|
|
|
|
collision_segments.push_back(Vector3(a.x, 0, a.y) + d);
|
|
collision_segments.push_back(Vector3(a.x, 0, a.y) - d);
|
|
}
|
|
}
|
|
|
|
p_gizmo->add_collision_segments(collision_segments);
|
|
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(cs2->get_radius(), 0, 0));
|
|
handles.push_back(Vector3(0, cs2->get_height() * 0.5, 0));
|
|
p_gizmo->add_handles(handles, handles_material);
|
|
}
|
|
|
|
if (Object::cast_to<PlaneShape>(*s)) {
|
|
|
|
Ref<PlaneShape> ps = s;
|
|
Plane p = ps->get_plane();
|
|
Vector<Vector3> points;
|
|
|
|
Vector3 n1 = p.get_any_perpendicular_normal();
|
|
Vector3 n2 = p.normal.cross(n1).normalized();
|
|
|
|
Vector3 pface[4] = {
|
|
p.normal * p.d + n1 * 10.0 + n2 * 10.0,
|
|
p.normal * p.d + n1 * 10.0 + n2 * -10.0,
|
|
p.normal * p.d + n1 * -10.0 + n2 * -10.0,
|
|
p.normal * p.d + n1 * -10.0 + n2 * 10.0,
|
|
};
|
|
|
|
points.push_back(pface[0]);
|
|
points.push_back(pface[1]);
|
|
points.push_back(pface[1]);
|
|
points.push_back(pface[2]);
|
|
points.push_back(pface[2]);
|
|
points.push_back(pface[3]);
|
|
points.push_back(pface[3]);
|
|
points.push_back(pface[0]);
|
|
points.push_back(p.normal * p.d);
|
|
points.push_back(p.normal * p.d + p.normal * 3);
|
|
|
|
p_gizmo->add_lines(points, material);
|
|
p_gizmo->add_collision_segments(points);
|
|
}
|
|
|
|
if (Object::cast_to<ConvexPolygonShape>(*s)) {
|
|
|
|
PoolVector<Vector3> points = Object::cast_to<ConvexPolygonShape>(*s)->get_points();
|
|
|
|
if (points.size() > 3) {
|
|
|
|
Vector<Vector3> varr = Variant(points);
|
|
Geometry::MeshData md;
|
|
Error err = QuickHull::build(varr, md);
|
|
if (err == OK) {
|
|
Vector<Vector3> points2;
|
|
points2.resize(md.edges.size() * 2);
|
|
for (int i = 0; i < md.edges.size(); i++) {
|
|
points2.write[i * 2 + 0] = md.vertices[md.edges[i].a];
|
|
points2.write[i * 2 + 1] = md.vertices[md.edges[i].b];
|
|
}
|
|
|
|
p_gizmo->add_lines(points2, material);
|
|
p_gizmo->add_collision_segments(points2);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Object::cast_to<ConcavePolygonShape>(*s)) {
|
|
|
|
Ref<ConcavePolygonShape> cs2 = s;
|
|
Ref<ArrayMesh> mesh = cs2->get_debug_mesh();
|
|
p_gizmo->add_mesh(mesh, false, RID(), material);
|
|
}
|
|
|
|
if (Object::cast_to<RayShape>(*s)) {
|
|
|
|
Ref<RayShape> rs = s;
|
|
|
|
Vector<Vector3> points;
|
|
points.push_back(Vector3());
|
|
points.push_back(Vector3(0, 0, rs->get_length()));
|
|
p_gizmo->add_lines(points, material);
|
|
p_gizmo->add_collision_segments(points);
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(0, 0, rs->get_length()));
|
|
p_gizmo->add_handles(handles, handles_material);
|
|
}
|
|
|
|
if (Object::cast_to<HeightMapShape>(*s)) {
|
|
|
|
Ref<HeightMapShape> hms = s;
|
|
|
|
Ref<ArrayMesh> mesh = hms->get_debug_mesh();
|
|
p_gizmo->add_mesh(mesh, false, RID(), material);
|
|
}
|
|
}
|
|
|
|
/////
|
|
|
|
CollisionPolygonSpatialGizmoPlugin::CollisionPolygonSpatialGizmoPlugin() {
|
|
const Color gizmo_color = EDITOR_DEF("editors/3d_gizmos/gizmo_colors/shape", Color(0.5, 0.7, 1));
|
|
create_material("shape_material", gizmo_color);
|
|
const float gizmo_value = gizmo_color.get_v();
|
|
const Color gizmo_color_disabled = Color(gizmo_value, gizmo_value, gizmo_value, 0.65);
|
|
create_material("shape_material_disabled", gizmo_color_disabled);
|
|
}
|
|
|
|
bool CollisionPolygonSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<CollisionPolygon>(p_spatial) != NULL;
|
|
}
|
|
|
|
String CollisionPolygonSpatialGizmoPlugin::get_name() const {
|
|
return "CollisionPolygon";
|
|
}
|
|
|
|
int CollisionPolygonSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void CollisionPolygonSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
CollisionPolygon *polygon = Object::cast_to<CollisionPolygon>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
Vector<Vector2> points = polygon->get_polygon();
|
|
float depth = polygon->get_depth() * 0.5;
|
|
|
|
Vector<Vector3> lines;
|
|
for (int i = 0; i < points.size(); i++) {
|
|
|
|
int n = (i + 1) % points.size();
|
|
lines.push_back(Vector3(points[i].x, points[i].y, depth));
|
|
lines.push_back(Vector3(points[n].x, points[n].y, depth));
|
|
lines.push_back(Vector3(points[i].x, points[i].y, -depth));
|
|
lines.push_back(Vector3(points[n].x, points[n].y, -depth));
|
|
lines.push_back(Vector3(points[i].x, points[i].y, depth));
|
|
lines.push_back(Vector3(points[i].x, points[i].y, -depth));
|
|
}
|
|
|
|
const Ref<Material> material =
|
|
get_material(!polygon->is_disabled() ? "shape_material" : "shape_material_disabled", p_gizmo);
|
|
|
|
p_gizmo->add_lines(lines, material);
|
|
p_gizmo->add_collision_segments(lines);
|
|
}
|
|
|
|
////
|
|
|
|
NavigationMeshSpatialGizmoPlugin::NavigationMeshSpatialGizmoPlugin() {
|
|
create_material("navigation_edge_material", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/navigation_edge", Color(0.5, 1, 1)));
|
|
create_material("navigation_edge_material_disabled", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/navigation_edge_disabled", Color(0.7, 0.7, 0.7)));
|
|
create_material("navigation_solid_material", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/navigation_solid", Color(0.5, 1, 1, 0.4)));
|
|
create_material("navigation_solid_material_disabled", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/navigation_solid_disabled", Color(0.7, 0.7, 0.7, 0.4)));
|
|
}
|
|
|
|
bool NavigationMeshSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<NavigationMeshInstance>(p_spatial) != NULL;
|
|
}
|
|
|
|
String NavigationMeshSpatialGizmoPlugin::get_name() const {
|
|
return "NavigationMeshInstance";
|
|
}
|
|
|
|
int NavigationMeshSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void NavigationMeshSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
|
|
NavigationMeshInstance *navmesh = Object::cast_to<NavigationMeshInstance>(p_gizmo->get_spatial_node());
|
|
|
|
Ref<Material> edge_material = get_material("navigation_edge_material", p_gizmo);
|
|
Ref<Material> edge_material_disabled = get_material("navigation_edge_material_disabled", p_gizmo);
|
|
Ref<Material> solid_material = get_material("navigation_solid_material", p_gizmo);
|
|
Ref<Material> solid_material_disabled = get_material("navigation_solid_material_disabled", p_gizmo);
|
|
|
|
p_gizmo->clear();
|
|
Ref<NavigationMesh> navmeshie = navmesh->get_navigation_mesh();
|
|
if (navmeshie.is_null())
|
|
return;
|
|
|
|
PoolVector<Vector3> vertices = navmeshie->get_vertices();
|
|
PoolVector<Vector3>::Read vr = vertices.read();
|
|
List<Face3> faces;
|
|
for (int i = 0; i < navmeshie->get_polygon_count(); i++) {
|
|
Vector<int> p = navmeshie->get_polygon(i);
|
|
|
|
for (int j = 2; j < p.size(); j++) {
|
|
Face3 f;
|
|
f.vertex[0] = vr[p[0]];
|
|
f.vertex[1] = vr[p[j - 1]];
|
|
f.vertex[2] = vr[p[j]];
|
|
|
|
faces.push_back(f);
|
|
}
|
|
}
|
|
|
|
if (faces.empty())
|
|
return;
|
|
|
|
Map<_EdgeKey, bool> edge_map;
|
|
PoolVector<Vector3> tmeshfaces;
|
|
tmeshfaces.resize(faces.size() * 3);
|
|
|
|
{
|
|
PoolVector<Vector3>::Write tw = tmeshfaces.write();
|
|
int tidx = 0;
|
|
|
|
for (List<Face3>::Element *E = faces.front(); E; E = E->next()) {
|
|
|
|
const Face3 &f = E->get();
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
tw[tidx++] = f.vertex[j];
|
|
_EdgeKey ek;
|
|
ek.from = f.vertex[j].snapped(Vector3(CMP_EPSILON, CMP_EPSILON, CMP_EPSILON));
|
|
ek.to = f.vertex[(j + 1) % 3].snapped(Vector3(CMP_EPSILON, CMP_EPSILON, CMP_EPSILON));
|
|
if (ek.from < ek.to)
|
|
SWAP(ek.from, ek.to);
|
|
|
|
Map<_EdgeKey, bool>::Element *F = edge_map.find(ek);
|
|
|
|
if (F) {
|
|
|
|
F->get() = false;
|
|
|
|
} else {
|
|
|
|
edge_map[ek] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Vector<Vector3> lines;
|
|
|
|
for (Map<_EdgeKey, bool>::Element *E = edge_map.front(); E; E = E->next()) {
|
|
|
|
if (E->get()) {
|
|
lines.push_back(E->key().from);
|
|
lines.push_back(E->key().to);
|
|
}
|
|
}
|
|
|
|
Ref<TriangleMesh> tmesh = memnew(TriangleMesh);
|
|
tmesh->create(tmeshfaces);
|
|
|
|
if (lines.size())
|
|
p_gizmo->add_lines(lines, navmesh->is_enabled() ? edge_material : edge_material_disabled);
|
|
p_gizmo->add_collision_triangles(tmesh);
|
|
Ref<ArrayMesh> m = memnew(ArrayMesh);
|
|
Array a;
|
|
a.resize(Mesh::ARRAY_MAX);
|
|
a[0] = tmeshfaces;
|
|
m->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a);
|
|
m->surface_set_material(0, navmesh->is_enabled() ? solid_material : solid_material_disabled);
|
|
p_gizmo->add_mesh(m);
|
|
p_gizmo->add_collision_segments(lines);
|
|
}
|
|
|
|
//////
|
|
|
|
#define BODY_A_RADIUS 0.25
|
|
#define BODY_B_RADIUS 0.27
|
|
|
|
Basis JointGizmosDrawer::look_body(const Transform &p_joint_transform, const Transform &p_body_transform) {
|
|
const Vector3 &p_eye(p_joint_transform.origin);
|
|
const Vector3 &p_target(p_body_transform.origin);
|
|
|
|
Vector3 v_x, v_y, v_z;
|
|
|
|
// Look the body with X
|
|
v_x = p_target - p_eye;
|
|
v_x.normalize();
|
|
|
|
v_z = v_x.cross(Vector3(0, 1, 0));
|
|
v_z.normalize();
|
|
|
|
v_y = v_z.cross(v_x);
|
|
v_y.normalize();
|
|
|
|
Basis base;
|
|
base.set(v_x, v_y, v_z);
|
|
|
|
// Absorb current joint transform
|
|
base = p_joint_transform.basis.inverse() * base;
|
|
|
|
return base;
|
|
}
|
|
|
|
Basis JointGizmosDrawer::look_body_toward(Vector3::Axis p_axis, const Transform &joint_transform, const Transform &body_transform) {
|
|
|
|
switch (p_axis) {
|
|
case Vector3::AXIS_X:
|
|
return look_body_toward_x(joint_transform, body_transform);
|
|
case Vector3::AXIS_Y:
|
|
return look_body_toward_y(joint_transform, body_transform);
|
|
case Vector3::AXIS_Z:
|
|
return look_body_toward_z(joint_transform, body_transform);
|
|
default:
|
|
return Basis();
|
|
}
|
|
}
|
|
|
|
Basis JointGizmosDrawer::look_body_toward_x(const Transform &p_joint_transform, const Transform &p_body_transform) {
|
|
|
|
const Vector3 &p_eye(p_joint_transform.origin);
|
|
const Vector3 &p_target(p_body_transform.origin);
|
|
|
|
const Vector3 p_front(p_joint_transform.basis.get_axis(0));
|
|
|
|
Vector3 v_x, v_y, v_z;
|
|
|
|
// Look the body with X
|
|
v_x = p_target - p_eye;
|
|
v_x.normalize();
|
|
|
|
v_y = p_front.cross(v_x);
|
|
v_y.normalize();
|
|
|
|
v_z = v_y.cross(p_front);
|
|
v_z.normalize();
|
|
|
|
// Clamp X to FRONT axis
|
|
v_x = p_front;
|
|
v_x.normalize();
|
|
|
|
Basis base;
|
|
base.set(v_x, v_y, v_z);
|
|
|
|
// Absorb current joint transform
|
|
base = p_joint_transform.basis.inverse() * base;
|
|
|
|
return base;
|
|
}
|
|
|
|
Basis JointGizmosDrawer::look_body_toward_y(const Transform &p_joint_transform, const Transform &p_body_transform) {
|
|
|
|
const Vector3 &p_eye(p_joint_transform.origin);
|
|
const Vector3 &p_target(p_body_transform.origin);
|
|
|
|
const Vector3 p_up(p_joint_transform.basis.get_axis(1));
|
|
|
|
Vector3 v_x, v_y, v_z;
|
|
|
|
// Look the body with X
|
|
v_x = p_target - p_eye;
|
|
v_x.normalize();
|
|
|
|
v_z = v_x.cross(p_up);
|
|
v_z.normalize();
|
|
|
|
v_x = p_up.cross(v_z);
|
|
v_x.normalize();
|
|
|
|
// Clamp Y to UP axis
|
|
v_y = p_up;
|
|
v_y.normalize();
|
|
|
|
Basis base;
|
|
base.set(v_x, v_y, v_z);
|
|
|
|
// Absorb current joint transform
|
|
base = p_joint_transform.basis.inverse() * base;
|
|
|
|
return base;
|
|
}
|
|
|
|
Basis JointGizmosDrawer::look_body_toward_z(const Transform &p_joint_transform, const Transform &p_body_transform) {
|
|
|
|
const Vector3 &p_eye(p_joint_transform.origin);
|
|
const Vector3 &p_target(p_body_transform.origin);
|
|
|
|
const Vector3 p_lateral(p_joint_transform.basis.get_axis(2));
|
|
|
|
Vector3 v_x, v_y, v_z;
|
|
|
|
// Look the body with X
|
|
v_x = p_target - p_eye;
|
|
v_x.normalize();
|
|
|
|
v_z = p_lateral;
|
|
v_z.normalize();
|
|
|
|
v_y = v_z.cross(v_x);
|
|
v_y.normalize();
|
|
|
|
// Clamp X to Z axis
|
|
v_x = v_y.cross(v_z);
|
|
v_x.normalize();
|
|
|
|
Basis base;
|
|
base.set(v_x, v_y, v_z);
|
|
|
|
// Absorb current joint transform
|
|
base = p_joint_transform.basis.inverse() * base;
|
|
|
|
return base;
|
|
}
|
|
|
|
void JointGizmosDrawer::draw_circle(Vector3::Axis p_axis, real_t p_radius, const Transform &p_offset, const Basis &p_base, real_t p_limit_lower, real_t p_limit_upper, Vector<Vector3> &r_points, bool p_inverse) {
|
|
|
|
if (p_limit_lower == p_limit_upper) {
|
|
|
|
r_points.push_back(p_offset.translated(Vector3()).origin);
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3(0.5, 0, 0))).origin);
|
|
|
|
} else {
|
|
|
|
if (p_limit_lower > p_limit_upper) {
|
|
p_limit_lower = -Math_PI;
|
|
p_limit_upper = Math_PI;
|
|
}
|
|
|
|
const int points = 32;
|
|
|
|
for (int i = 0; i < points; i++) {
|
|
|
|
real_t s = p_limit_lower + i * (p_limit_upper - p_limit_lower) / points;
|
|
real_t n = p_limit_lower + (i + 1) * (p_limit_upper - p_limit_lower) / points;
|
|
|
|
Vector3 from;
|
|
Vector3 to;
|
|
switch (p_axis) {
|
|
case Vector3::AXIS_X:
|
|
if (p_inverse) {
|
|
from = p_base.xform(Vector3(0, Math::sin(s), Math::cos(s))) * p_radius;
|
|
to = p_base.xform(Vector3(0, Math::sin(n), Math::cos(n))) * p_radius;
|
|
} else {
|
|
from = p_base.xform(Vector3(0, -Math::sin(s), Math::cos(s))) * p_radius;
|
|
to = p_base.xform(Vector3(0, -Math::sin(n), Math::cos(n))) * p_radius;
|
|
}
|
|
break;
|
|
case Vector3::AXIS_Y:
|
|
if (p_inverse) {
|
|
from = p_base.xform(Vector3(Math::cos(s), 0, -Math::sin(s))) * p_radius;
|
|
to = p_base.xform(Vector3(Math::cos(n), 0, -Math::sin(n))) * p_radius;
|
|
} else {
|
|
from = p_base.xform(Vector3(Math::cos(s), 0, Math::sin(s))) * p_radius;
|
|
to = p_base.xform(Vector3(Math::cos(n), 0, Math::sin(n))) * p_radius;
|
|
}
|
|
break;
|
|
case Vector3::AXIS_Z:
|
|
from = p_base.xform(Vector3(Math::cos(s), Math::sin(s), 0)) * p_radius;
|
|
to = p_base.xform(Vector3(Math::cos(n), Math::sin(n), 0)) * p_radius;
|
|
break;
|
|
}
|
|
|
|
if (i == points - 1) {
|
|
r_points.push_back(p_offset.translated(to).origin);
|
|
r_points.push_back(p_offset.translated(Vector3()).origin);
|
|
}
|
|
if (i == 0) {
|
|
r_points.push_back(p_offset.translated(from).origin);
|
|
r_points.push_back(p_offset.translated(Vector3()).origin);
|
|
}
|
|
|
|
r_points.push_back(p_offset.translated(from).origin);
|
|
r_points.push_back(p_offset.translated(to).origin);
|
|
}
|
|
|
|
r_points.push_back(p_offset.translated(Vector3(0, p_radius * 1.5, 0)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3()).origin);
|
|
}
|
|
}
|
|
|
|
void JointGizmosDrawer::draw_cone(const Transform &p_offset, const Basis &p_base, real_t p_swing, real_t p_twist, Vector<Vector3> &r_points) {
|
|
|
|
float r = 1.0;
|
|
float w = r * Math::sin(p_swing);
|
|
float d = r * Math::cos(p_swing);
|
|
|
|
//swing
|
|
for (int i = 0; i < 360; i += 10) {
|
|
|
|
float ra = Math::deg2rad((float)i);
|
|
float rb = Math::deg2rad((float)i + 10);
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * w;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * w;
|
|
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3(d, a.x, a.y))).origin);
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3(d, b.x, b.y))).origin);
|
|
|
|
if (i % 90 == 0) {
|
|
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3(d, a.x, a.y))).origin);
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3())).origin);
|
|
}
|
|
}
|
|
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3())).origin);
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3(1, 0, 0))).origin);
|
|
|
|
/// Twist
|
|
float ts = Math::rad2deg(p_twist);
|
|
ts = MIN(ts, 720);
|
|
|
|
for (int i = 0; i < int(ts); i += 5) {
|
|
|
|
float ra = Math::deg2rad((float)i);
|
|
float rb = Math::deg2rad((float)i + 5);
|
|
float c = i / 720.0;
|
|
float cn = (i + 5) / 720.0;
|
|
Point2 a = Vector2(Math::sin(ra), Math::cos(ra)) * w * c;
|
|
Point2 b = Vector2(Math::sin(rb), Math::cos(rb)) * w * cn;
|
|
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3(c, a.x, a.y))).origin);
|
|
r_points.push_back(p_offset.translated(p_base.xform(Vector3(cn, b.x, b.y))).origin);
|
|
}
|
|
}
|
|
|
|
////
|
|
|
|
JointSpatialGizmoPlugin::JointSpatialGizmoPlugin() {
|
|
create_material("joint_material", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/joint", Color(0.5, 0.8, 1)));
|
|
create_material("joint_body_a_material", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/joint_body_a", Color(0.6, 0.8, 1)));
|
|
create_material("joint_body_b_material", EDITOR_DEF("editors/3d_gizmos/gizmo_colors/joint_body_b", Color(0.6, 0.9, 1)));
|
|
}
|
|
|
|
bool JointSpatialGizmoPlugin::has_gizmo(Spatial *p_spatial) {
|
|
return Object::cast_to<Joint>(p_spatial) != NULL;
|
|
}
|
|
|
|
String JointSpatialGizmoPlugin::get_name() const {
|
|
return "Joints";
|
|
}
|
|
|
|
int JointSpatialGizmoPlugin::get_priority() const {
|
|
return -1;
|
|
}
|
|
|
|
void JointSpatialGizmoPlugin::redraw(EditorSpatialGizmo *p_gizmo) {
|
|
Joint *joint = Object::cast_to<Joint>(p_gizmo->get_spatial_node());
|
|
|
|
p_gizmo->clear();
|
|
|
|
const Spatial *node_body_a = Object::cast_to<Spatial>(joint->get_node(joint->get_node_a()));
|
|
const Spatial *node_body_b = Object::cast_to<Spatial>(joint->get_node(joint->get_node_b()));
|
|
|
|
Ref<Material> common_material = get_material("joint_material", p_gizmo);
|
|
Ref<Material> body_a_material = get_material("joint_body_a_material", p_gizmo);
|
|
Ref<Material> body_b_material = get_material("joint_body_b_material", p_gizmo);
|
|
|
|
Vector<Vector3> points;
|
|
Vector<Vector3> body_a_points;
|
|
Vector<Vector3> body_b_points;
|
|
|
|
if (Object::cast_to<PinJoint>(joint)) {
|
|
CreatePinJointGizmo(Transform(), points);
|
|
p_gizmo->add_collision_segments(points);
|
|
p_gizmo->add_lines(points, common_material);
|
|
}
|
|
|
|
HingeJoint *hinge = Object::cast_to<HingeJoint>(joint);
|
|
if (hinge) {
|
|
|
|
CreateHingeJointGizmo(
|
|
Transform(),
|
|
hinge->get_global_transform(),
|
|
node_body_a ? node_body_a->get_global_transform() : Transform(),
|
|
node_body_b ? node_body_b->get_global_transform() : Transform(),
|
|
hinge->get_param(HingeJoint::PARAM_LIMIT_LOWER),
|
|
hinge->get_param(HingeJoint::PARAM_LIMIT_UPPER),
|
|
hinge->get_flag(HingeJoint::FLAG_USE_LIMIT),
|
|
points,
|
|
node_body_a ? &body_a_points : NULL,
|
|
node_body_b ? &body_b_points : NULL);
|
|
|
|
p_gizmo->add_collision_segments(points);
|
|
p_gizmo->add_collision_segments(body_a_points);
|
|
p_gizmo->add_collision_segments(body_b_points);
|
|
|
|
p_gizmo->add_lines(points, common_material);
|
|
p_gizmo->add_lines(body_a_points, body_a_material);
|
|
p_gizmo->add_lines(body_b_points, body_b_material);
|
|
}
|
|
|
|
SliderJoint *slider = Object::cast_to<SliderJoint>(joint);
|
|
if (slider) {
|
|
|
|
CreateSliderJointGizmo(
|
|
Transform(),
|
|
slider->get_global_transform(),
|
|
node_body_a ? node_body_a->get_global_transform() : Transform(),
|
|
node_body_b ? node_body_b->get_global_transform() : Transform(),
|
|
slider->get_param(SliderJoint::PARAM_ANGULAR_LIMIT_LOWER),
|
|
slider->get_param(SliderJoint::PARAM_ANGULAR_LIMIT_UPPER),
|
|
slider->get_param(SliderJoint::PARAM_LINEAR_LIMIT_LOWER),
|
|
slider->get_param(SliderJoint::PARAM_LINEAR_LIMIT_UPPER),
|
|
points,
|
|
node_body_a ? &body_a_points : NULL,
|
|
node_body_b ? &body_b_points : NULL);
|
|
|
|
p_gizmo->add_collision_segments(points);
|
|
p_gizmo->add_collision_segments(body_a_points);
|
|
p_gizmo->add_collision_segments(body_b_points);
|
|
|
|
p_gizmo->add_lines(points, common_material);
|
|
p_gizmo->add_lines(body_a_points, body_a_material);
|
|
p_gizmo->add_lines(body_b_points, body_b_material);
|
|
}
|
|
|
|
ConeTwistJoint *cone = Object::cast_to<ConeTwistJoint>(joint);
|
|
if (cone) {
|
|
|
|
CreateConeTwistJointGizmo(
|
|
Transform(),
|
|
cone->get_global_transform(),
|
|
node_body_a ? node_body_a->get_global_transform() : Transform(),
|
|
node_body_b ? node_body_b->get_global_transform() : Transform(),
|
|
cone->get_param(ConeTwistJoint::PARAM_SWING_SPAN),
|
|
cone->get_param(ConeTwistJoint::PARAM_TWIST_SPAN),
|
|
node_body_a ? &body_a_points : NULL,
|
|
node_body_b ? &body_b_points : NULL);
|
|
|
|
p_gizmo->add_collision_segments(body_a_points);
|
|
p_gizmo->add_collision_segments(body_b_points);
|
|
|
|
p_gizmo->add_lines(body_a_points, body_a_material);
|
|
p_gizmo->add_lines(body_b_points, body_b_material);
|
|
}
|
|
|
|
Generic6DOFJoint *gen = Object::cast_to<Generic6DOFJoint>(joint);
|
|
if (gen) {
|
|
|
|
CreateGeneric6DOFJointGizmo(
|
|
Transform(),
|
|
gen->get_global_transform(),
|
|
node_body_a ? node_body_a->get_global_transform() : Transform(),
|
|
node_body_b ? node_body_b->get_global_transform() : Transform(),
|
|
|
|
gen->get_param_x(Generic6DOFJoint::PARAM_ANGULAR_LOWER_LIMIT),
|
|
gen->get_param_x(Generic6DOFJoint::PARAM_ANGULAR_UPPER_LIMIT),
|
|
gen->get_param_x(Generic6DOFJoint::PARAM_LINEAR_LOWER_LIMIT),
|
|
gen->get_param_x(Generic6DOFJoint::PARAM_LINEAR_UPPER_LIMIT),
|
|
gen->get_flag_x(Generic6DOFJoint::FLAG_ENABLE_ANGULAR_LIMIT),
|
|
gen->get_flag_x(Generic6DOFJoint::FLAG_ENABLE_LINEAR_LIMIT),
|
|
|
|
gen->get_param_y(Generic6DOFJoint::PARAM_ANGULAR_LOWER_LIMIT),
|
|
gen->get_param_y(Generic6DOFJoint::PARAM_ANGULAR_UPPER_LIMIT),
|
|
gen->get_param_y(Generic6DOFJoint::PARAM_LINEAR_LOWER_LIMIT),
|
|
gen->get_param_y(Generic6DOFJoint::PARAM_LINEAR_UPPER_LIMIT),
|
|
gen->get_flag_y(Generic6DOFJoint::FLAG_ENABLE_ANGULAR_LIMIT),
|
|
gen->get_flag_y(Generic6DOFJoint::FLAG_ENABLE_LINEAR_LIMIT),
|
|
|
|
gen->get_param_z(Generic6DOFJoint::PARAM_ANGULAR_LOWER_LIMIT),
|
|
gen->get_param_z(Generic6DOFJoint::PARAM_ANGULAR_UPPER_LIMIT),
|
|
gen->get_param_z(Generic6DOFJoint::PARAM_LINEAR_LOWER_LIMIT),
|
|
gen->get_param_z(Generic6DOFJoint::PARAM_LINEAR_UPPER_LIMIT),
|
|
gen->get_flag_z(Generic6DOFJoint::FLAG_ENABLE_ANGULAR_LIMIT),
|
|
gen->get_flag_z(Generic6DOFJoint::FLAG_ENABLE_LINEAR_LIMIT),
|
|
|
|
points,
|
|
node_body_a ? &body_a_points : NULL,
|
|
node_body_a ? &body_b_points : NULL);
|
|
|
|
p_gizmo->add_collision_segments(points);
|
|
p_gizmo->add_collision_segments(body_a_points);
|
|
p_gizmo->add_collision_segments(body_b_points);
|
|
|
|
p_gizmo->add_lines(points, common_material);
|
|
p_gizmo->add_lines(body_a_points, body_a_material);
|
|
p_gizmo->add_lines(body_b_points, body_b_material);
|
|
}
|
|
}
|
|
|
|
void JointSpatialGizmoPlugin::CreatePinJointGizmo(const Transform &p_offset, Vector<Vector3> &r_cursor_points) {
|
|
float cs = 0.25;
|
|
|
|
r_cursor_points.push_back(p_offset.translated(Vector3(+cs, 0, 0)).origin);
|
|
r_cursor_points.push_back(p_offset.translated(Vector3(-cs, 0, 0)).origin);
|
|
r_cursor_points.push_back(p_offset.translated(Vector3(0, +cs, 0)).origin);
|
|
r_cursor_points.push_back(p_offset.translated(Vector3(0, -cs, 0)).origin);
|
|
r_cursor_points.push_back(p_offset.translated(Vector3(0, 0, +cs)).origin);
|
|
r_cursor_points.push_back(p_offset.translated(Vector3(0, 0, -cs)).origin);
|
|
}
|
|
|
|
void JointSpatialGizmoPlugin::CreateHingeJointGizmo(const Transform &p_offset, const Transform &p_trs_joint, const Transform &p_trs_body_a, const Transform &p_trs_body_b, real_t p_limit_lower, real_t p_limit_upper, bool p_use_limit, Vector<Vector3> &r_common_points, Vector<Vector3> *r_body_a_points, Vector<Vector3> *r_body_b_points) {
|
|
|
|
r_common_points.push_back(p_offset.translated(Vector3(0, 0, 0.5)).origin);
|
|
r_common_points.push_back(p_offset.translated(Vector3(0, 0, -0.5)).origin);
|
|
|
|
if (!p_use_limit) {
|
|
p_limit_upper = -1;
|
|
p_limit_lower = 0;
|
|
}
|
|
|
|
if (r_body_a_points) {
|
|
|
|
JointGizmosDrawer::draw_circle(Vector3::AXIS_Z,
|
|
BODY_A_RADIUS,
|
|
p_offset,
|
|
JointGizmosDrawer::look_body_toward_z(p_trs_joint, p_trs_body_a),
|
|
p_limit_lower,
|
|
p_limit_upper,
|
|
*r_body_a_points);
|
|
}
|
|
|
|
if (r_body_b_points) {
|
|
JointGizmosDrawer::draw_circle(Vector3::AXIS_Z,
|
|
BODY_B_RADIUS,
|
|
p_offset,
|
|
JointGizmosDrawer::look_body_toward_z(p_trs_joint, p_trs_body_b),
|
|
p_limit_lower,
|
|
p_limit_upper,
|
|
*r_body_b_points);
|
|
}
|
|
}
|
|
|
|
void JointSpatialGizmoPlugin::CreateSliderJointGizmo(const Transform &p_offset, const Transform &p_trs_joint, const Transform &p_trs_body_a, const Transform &p_trs_body_b, real_t p_angular_limit_lower, real_t p_angular_limit_upper, real_t p_linear_limit_lower, real_t p_linear_limit_upper, Vector<Vector3> &r_points, Vector<Vector3> *r_body_a_points, Vector<Vector3> *r_body_b_points) {
|
|
|
|
p_linear_limit_lower = -p_linear_limit_lower;
|
|
p_linear_limit_upper = -p_linear_limit_upper;
|
|
|
|
float cs = 0.25;
|
|
r_points.push_back(p_offset.translated(Vector3(0, 0, 0.5)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(0, 0, -0.5)).origin);
|
|
|
|
if (p_linear_limit_lower >= p_linear_limit_upper) {
|
|
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, 0, 0)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, 0, 0)).origin);
|
|
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, -cs, -cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, -cs, cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, -cs, cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, cs, cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, cs, cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, cs, -cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, cs, -cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_upper, -cs, -cs)).origin);
|
|
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, -cs, -cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, -cs, cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, -cs, cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, cs, cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, cs, cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, cs, -cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, cs, -cs)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(p_linear_limit_lower, -cs, -cs)).origin);
|
|
|
|
} else {
|
|
|
|
r_points.push_back(p_offset.translated(Vector3(+cs * 2, 0, 0)).origin);
|
|
r_points.push_back(p_offset.translated(Vector3(-cs * 2, 0, 0)).origin);
|
|
}
|
|
|
|
if (r_body_a_points)
|
|
JointGizmosDrawer::draw_circle(
|
|
Vector3::AXIS_X,
|
|
BODY_A_RADIUS,
|
|
p_offset,
|
|
JointGizmosDrawer::look_body_toward(Vector3::AXIS_X, p_trs_joint, p_trs_body_a),
|
|
p_angular_limit_lower,
|
|
p_angular_limit_upper,
|
|
*r_body_a_points);
|
|
|
|
if (r_body_b_points)
|
|
JointGizmosDrawer::draw_circle(
|
|
Vector3::AXIS_X,
|
|
BODY_B_RADIUS,
|
|
p_offset,
|
|
JointGizmosDrawer::look_body_toward(Vector3::AXIS_X, p_trs_joint, p_trs_body_b),
|
|
p_angular_limit_lower,
|
|
p_angular_limit_upper,
|
|
*r_body_b_points,
|
|
true);
|
|
}
|
|
|
|
void JointSpatialGizmoPlugin::CreateConeTwistJointGizmo(const Transform &p_offset, const Transform &p_trs_joint, const Transform &p_trs_body_a, const Transform &p_trs_body_b, real_t p_swing, real_t p_twist, Vector<Vector3> *r_body_a_points, Vector<Vector3> *r_body_b_points) {
|
|
|
|
if (r_body_a_points)
|
|
JointGizmosDrawer::draw_cone(
|
|
p_offset,
|
|
JointGizmosDrawer::look_body(p_trs_joint, p_trs_body_a),
|
|
p_swing,
|
|
p_twist,
|
|
*r_body_a_points);
|
|
|
|
if (r_body_b_points)
|
|
JointGizmosDrawer::draw_cone(
|
|
p_offset,
|
|
JointGizmosDrawer::look_body(p_trs_joint, p_trs_body_b),
|
|
p_swing,
|
|
p_twist,
|
|
*r_body_b_points);
|
|
}
|
|
|
|
void JointSpatialGizmoPlugin::CreateGeneric6DOFJointGizmo(
|
|
const Transform &p_offset,
|
|
const Transform &p_trs_joint,
|
|
const Transform &p_trs_body_a,
|
|
const Transform &p_trs_body_b,
|
|
real_t p_angular_limit_lower_x,
|
|
real_t p_angular_limit_upper_x,
|
|
real_t p_linear_limit_lower_x,
|
|
real_t p_linear_limit_upper_x,
|
|
bool p_enable_angular_limit_x,
|
|
bool p_enable_linear_limit_x,
|
|
real_t p_angular_limit_lower_y,
|
|
real_t p_angular_limit_upper_y,
|
|
real_t p_linear_limit_lower_y,
|
|
real_t p_linear_limit_upper_y,
|
|
bool p_enable_angular_limit_y,
|
|
bool p_enable_linear_limit_y,
|
|
real_t p_angular_limit_lower_z,
|
|
real_t p_angular_limit_upper_z,
|
|
real_t p_linear_limit_lower_z,
|
|
real_t p_linear_limit_upper_z,
|
|
bool p_enable_angular_limit_z,
|
|
bool p_enable_linear_limit_z,
|
|
Vector<Vector3> &r_points,
|
|
Vector<Vector3> *r_body_a_points,
|
|
Vector<Vector3> *r_body_b_points) {
|
|
|
|
float cs = 0.25;
|
|
|
|
for (int ax = 0; ax < 3; ax++) {
|
|
float ll = 0;
|
|
float ul = 0;
|
|
float lll = 0;
|
|
float lul = 0;
|
|
|
|
int a1 = 0;
|
|
int a2 = 0;
|
|
int a3 = 0;
|
|
bool enable_ang = false;
|
|
bool enable_lin = false;
|
|
|
|
switch (ax) {
|
|
case 0:
|
|
ll = p_angular_limit_lower_x;
|
|
ul = p_angular_limit_upper_x;
|
|
lll = -p_linear_limit_lower_x;
|
|
lul = -p_linear_limit_upper_x;
|
|
enable_ang = p_enable_angular_limit_x;
|
|
enable_lin = p_enable_linear_limit_x;
|
|
a1 = 0;
|
|
a2 = 1;
|
|
a3 = 2;
|
|
break;
|
|
case 1:
|
|
ll = p_angular_limit_lower_y;
|
|
ul = p_angular_limit_upper_y;
|
|
lll = -p_linear_limit_lower_y;
|
|
lul = -p_linear_limit_upper_y;
|
|
enable_ang = p_enable_angular_limit_y;
|
|
enable_lin = p_enable_linear_limit_y;
|
|
a1 = 1;
|
|
a2 = 2;
|
|
a3 = 0;
|
|
break;
|
|
case 2:
|
|
ll = p_angular_limit_lower_z;
|
|
ul = p_angular_limit_upper_z;
|
|
lll = -p_linear_limit_lower_z;
|
|
lul = -p_linear_limit_upper_z;
|
|
enable_ang = p_enable_angular_limit_z;
|
|
enable_lin = p_enable_linear_limit_z;
|
|
a1 = 2;
|
|
a2 = 0;
|
|
a3 = 1;
|
|
break;
|
|
}
|
|
|
|
#define ADD_VTX(x, y, z) \
|
|
{ \
|
|
Vector3 v; \
|
|
v[a1] = (x); \
|
|
v[a2] = (y); \
|
|
v[a3] = (z); \
|
|
r_points.push_back(p_offset.translated(v).origin); \
|
|
}
|
|
|
|
if (enable_lin && lll >= lul) {
|
|
|
|
ADD_VTX(lul, 0, 0);
|
|
ADD_VTX(lll, 0, 0);
|
|
|
|
ADD_VTX(lul, -cs, -cs);
|
|
ADD_VTX(lul, -cs, cs);
|
|
ADD_VTX(lul, -cs, cs);
|
|
ADD_VTX(lul, cs, cs);
|
|
ADD_VTX(lul, cs, cs);
|
|
ADD_VTX(lul, cs, -cs);
|
|
ADD_VTX(lul, cs, -cs);
|
|
ADD_VTX(lul, -cs, -cs);
|
|
|
|
ADD_VTX(lll, -cs, -cs);
|
|
ADD_VTX(lll, -cs, cs);
|
|
ADD_VTX(lll, -cs, cs);
|
|
ADD_VTX(lll, cs, cs);
|
|
ADD_VTX(lll, cs, cs);
|
|
ADD_VTX(lll, cs, -cs);
|
|
ADD_VTX(lll, cs, -cs);
|
|
ADD_VTX(lll, -cs, -cs);
|
|
|
|
} else {
|
|
|
|
ADD_VTX(+cs * 2, 0, 0);
|
|
ADD_VTX(-cs * 2, 0, 0);
|
|
}
|
|
|
|
if (!enable_ang) {
|
|
ll = 0;
|
|
ul = -1;
|
|
}
|
|
|
|
if (r_body_a_points)
|
|
JointGizmosDrawer::draw_circle(
|
|
static_cast<Vector3::Axis>(ax),
|
|
BODY_A_RADIUS,
|
|
p_offset,
|
|
JointGizmosDrawer::look_body_toward(static_cast<Vector3::Axis>(ax), p_trs_joint, p_trs_body_a),
|
|
ll,
|
|
ul,
|
|
*r_body_a_points,
|
|
true);
|
|
|
|
if (r_body_b_points)
|
|
JointGizmosDrawer::draw_circle(
|
|
static_cast<Vector3::Axis>(ax),
|
|
BODY_B_RADIUS,
|
|
p_offset,
|
|
JointGizmosDrawer::look_body_toward(static_cast<Vector3::Axis>(ax), p_trs_joint, p_trs_body_b),
|
|
ll,
|
|
ul,
|
|
*r_body_b_points);
|
|
}
|
|
|
|
#undef ADD_VTX
|
|
}
|