2330 lines
58 KiB
C++
2330 lines
58 KiB
C++
/*************************************************************************/
|
|
/* spatial_editor_gizmos.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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 "geometry.h"
|
|
#include "scene/3d/camera.h"
|
|
#include "scene/resources/surface_tool.h"
|
|
#include "scene/resources/sphere_shape.h"
|
|
#include "scene/resources/box_shape.h"
|
|
#include "scene/resources/capsule_shape.h"
|
|
#include "scene/resources/ray_shape.h"
|
|
#include "scene/resources/convex_polygon_shape.h"
|
|
#include "scene/resources/plane_shape.h"
|
|
#include "editor_shape_gizmos.h"
|
|
|
|
// Keep small children away from this file.
|
|
// It's so ugly it will eat them alive
|
|
|
|
#define HANDLE_HALF_SIZE 0.05
|
|
|
|
void SpatialGizmoTool::clear() {
|
|
|
|
for(int i=0;i<instances.size();i++) {
|
|
|
|
if (instances[i].instance.is_valid())
|
|
VS::get_singleton()->free(instances[i].instance);
|
|
|
|
|
|
}
|
|
|
|
collision_segments.clear();
|
|
collision_mesh=Ref<TriangleMesh>();
|
|
instances.clear();
|
|
handles.clear();
|
|
secondary_handles.clear();
|
|
}
|
|
|
|
void SpatialGizmoTool::Instance::create_instance(Spatial *p_base) {
|
|
|
|
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 (billboard)
|
|
VS::get_singleton()->instance_geometry_set_flag(instance,VS::INSTANCE_FLAG_BILLBOARD,true);
|
|
if (unscaled)
|
|
VS::get_singleton()->instance_geometry_set_flag(instance,VS::INSTANCE_FLAG_DEPH_SCALE,true);
|
|
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_flag(instance,VS::INSTANCE_FLAG_CAST_SHADOW,false);
|
|
VS::get_singleton()->instance_geometry_set_flag(instance,VS::INSTANCE_FLAG_RECEIVE_SHADOWS,false);
|
|
}
|
|
|
|
|
|
|
|
void SpatialGizmoTool::add_mesh(const Ref<Mesh>& p_mesh,bool p_billboard, const RID &p_skeleton) {
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
Instance ins;
|
|
|
|
ins.billboard=p_billboard;
|
|
ins.mesh=p_mesh;
|
|
ins.skeleton=p_skeleton;
|
|
if (valid) {
|
|
ins.create_instance(spatial_node);
|
|
VS::get_singleton()->instance_set_transform(ins.instance,spatial_node->get_global_transform());
|
|
}
|
|
|
|
instances.push_back(ins);
|
|
|
|
}
|
|
|
|
void SpatialGizmoTool::add_lines(const Vector<Vector3> &p_lines, const Ref<Material> &p_material,bool p_billboard){
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
Instance ins;
|
|
|
|
Ref<Mesh> mesh = memnew( Mesh );
|
|
Array a;
|
|
a.resize(Mesh::ARRAY_MAX);
|
|
a[Mesh::ARRAY_VERTEX]=p_lines;
|
|
mesh->add_surface(Mesh::PRIMITIVE_LINES,a);
|
|
mesh->surface_set_material(0,p_material);
|
|
|
|
|
|
ins.billboard=p_billboard;
|
|
ins.mesh=mesh;
|
|
if (valid) {
|
|
ins.create_instance(spatial_node);
|
|
VS::get_singleton()->instance_set_transform(ins.instance,spatial_node->get_global_transform());
|
|
}
|
|
|
|
instances.push_back(ins);
|
|
|
|
}
|
|
|
|
void SpatialGizmoTool::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(1,0));
|
|
uv.push_back(Vector2(0,0));
|
|
uv.push_back(Vector2(0,1));
|
|
uv.push_back(Vector2(1,1));
|
|
|
|
Ref<Mesh> mesh = memnew( Mesh );
|
|
Array a;
|
|
a.resize(Mesh::ARRAY_MAX);
|
|
a[Mesh::ARRAY_VERTEX]=vs;
|
|
a[Mesh::ARRAY_TEX_UV]=uv;
|
|
mesh->add_surface(Mesh::PRIMITIVE_TRIANGLE_FAN,a);
|
|
mesh->surface_set_material(0,p_material);
|
|
|
|
|
|
ins.mesh=mesh;
|
|
ins.unscaled=true;
|
|
ins.billboard=true;
|
|
if (valid) {
|
|
ins.create_instance(spatial_node);
|
|
VS::get_singleton()->instance_set_transform(ins.instance,spatial_node->get_global_transform());
|
|
}
|
|
|
|
instances.push_back(ins);
|
|
|
|
|
|
}
|
|
|
|
void SpatialGizmoTool::add_collision_triangles(const Ref<TriangleMesh>& p_tmesh) {
|
|
|
|
collision_mesh=p_tmesh;
|
|
}
|
|
|
|
void SpatialGizmoTool::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[from+i]=p_lines[i];
|
|
}
|
|
}
|
|
|
|
|
|
void SpatialGizmoTool::add_handles(const Vector<Vector3> &p_handles, bool p_billboard,bool p_secondary){
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
Instance ins;
|
|
|
|
billboard_handle=p_billboard;
|
|
|
|
Ref<Mesh> mesh = memnew( Mesh );
|
|
#if 1
|
|
|
|
Array a;
|
|
a.resize(VS::ARRAY_MAX);
|
|
a[VS::ARRAY_VERTEX]=p_handles;
|
|
mesh->add_surface(Mesh::PRIMITIVE_POINTS,a);
|
|
mesh->surface_set_material(0,SpatialEditorGizmos::singleton->handle2_material);
|
|
|
|
|
|
#else
|
|
for(int ih=0;ih<p_handles.size();ih++) {
|
|
|
|
|
|
Vector<Vector3> vertices;
|
|
Vector<Vector3> normals;
|
|
|
|
int vtx_idx=0;
|
|
#define ADD_VTX(m_idx);\
|
|
vertices.push_back( (face_points[m_idx]*HANDLE_HALF_SIZE+p_handles[ih]) );\
|
|
normals.push_back( normal_points[m_idx] );\
|
|
vtx_idx++;\
|
|
|
|
for (int i=0;i<6;i++) {
|
|
|
|
|
|
Vector3 face_points[4];
|
|
Vector3 normal_points[4];
|
|
float uv_points[8]={0,0,0,1,1,1,1,0};
|
|
|
|
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);
|
|
}
|
|
normal_points[j]=Vector3();
|
|
normal_points[j][i%3]=(i>=3?-1:1);
|
|
}
|
|
//tri 1
|
|
ADD_VTX(0);
|
|
ADD_VTX(1);
|
|
ADD_VTX(2);
|
|
//tri 2
|
|
ADD_VTX(2);
|
|
ADD_VTX(3);
|
|
ADD_VTX(0);
|
|
|
|
}
|
|
|
|
|
|
Array d;
|
|
d.resize(VS::ARRAY_MAX);
|
|
d[VisualServer::ARRAY_NORMAL]= normals ;
|
|
d[VisualServer::ARRAY_VERTEX]= vertices ;
|
|
|
|
mesh->add_surface(Mesh::PRIMITIVE_TRIANGLES,d);
|
|
mesh->surface_set_material(ih,SpatialEditorGizmos::singleton->handle_material);
|
|
|
|
|
|
}
|
|
#endif
|
|
ins.mesh=mesh;
|
|
ins.billboard=p_billboard;
|
|
ins.extra_margin=true;
|
|
if (valid) {
|
|
ins.create_instance(spatial_node);
|
|
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[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[i+chs]=p_handles[i];
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void SpatialGizmoTool::set_spatial_node(Spatial *p_node){
|
|
|
|
spatial_node=p_node;
|
|
|
|
}
|
|
|
|
bool SpatialGizmoTool::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 (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();
|
|
|
|
for(int i=0;i<vc/2;i++) {
|
|
|
|
|
|
Vector3 a=t.xform(vptr[i*2+0]);
|
|
Vector3 b=t.xform(vptr[i*2+1]);
|
|
|
|
bool any_out=false;
|
|
for(int j=0;j<fc;j++) {
|
|
|
|
if (p[j].distance_to(a) > 0 && p[j].distance_to(b) >0) {
|
|
|
|
any_out=true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!any_out)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool SpatialGizmoTool::intersect_ray(const 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 (r_gizmo_handle) {
|
|
|
|
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));
|
|
}
|
|
Transform ti=t.affine_inverse();
|
|
|
|
Vector3 ray_from=ti.xform(p_camera->project_ray_origin(p_point));
|
|
Vector3 ray_dir=t.basis.xform_inv(p_camera->project_ray_normal(p_point)).normalized();
|
|
Vector3 ray_to = ray_from+ray_dir*4096;
|
|
|
|
float min_d=1e20;
|
|
int idx=-1;
|
|
|
|
for(int i=0;i<secondary_handles.size();i++) {
|
|
#if 1
|
|
|
|
|
|
Vector3 hpos = t.xform(secondary_handles[i]);
|
|
Vector2 p = p_camera->unproject_position(hpos);
|
|
if (p.distance_to(p_point)<SpatialEditorGizmos::singleton->handle_t->get_width()*0.6) {
|
|
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
AABB aabb;
|
|
aabb.pos=Vector3(-1,-1,-1)*HANDLE_HALF_SIZE;
|
|
aabb.size=aabb.pos*-2;
|
|
aabb.pos+=secondary_handles[i];
|
|
|
|
|
|
Vector3 rpos,rnorm;
|
|
|
|
if (aabb.intersects_segment(ray_from,ray_to,&rpos,&rnorm)) {
|
|
|
|
real_t dp = ray_dir.dot(rpos);
|
|
if (dp<min_d) {
|
|
|
|
r_pos=t.xform(rpos);
|
|
r_normal=ti.basis.xform_inv(rnorm).normalized();
|
|
min_d=dp;
|
|
idx=i+handles.size();
|
|
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (p_sec_first && idx!=-1) {
|
|
|
|
*r_gizmo_handle=idx;
|
|
return true;
|
|
}
|
|
|
|
min_d=1e20;
|
|
|
|
for(int i=0;i<handles.size();i++) {
|
|
|
|
#if 1
|
|
|
|
|
|
Vector3 hpos = t.xform(handles[i]);
|
|
Vector2 p = p_camera->unproject_position(hpos);
|
|
if (p.distance_to(p_point)<SpatialEditorGizmos::singleton->handle_t->get_width()*0.6) {
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
AABB aabb;
|
|
aabb.pos=Vector3(-1,-1,-1)*HANDLE_HALF_SIZE;
|
|
aabb.size=aabb.pos*-2;
|
|
aabb.pos+=handles[i];
|
|
|
|
|
|
Vector3 rpos,rnorm;
|
|
|
|
if (aabb.intersects_segment(ray_from,ray_to,&rpos,&rnorm)) {
|
|
|
|
real_t dp = ray_dir.dot(rpos);
|
|
if (dp<min_d) {
|
|
|
|
r_pos=t.xform(rpos);
|
|
r_normal=ti.basis.xform_inv(rnorm).normalized();
|
|
min_d=dp;
|
|
idx=i;
|
|
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (idx>=0) {
|
|
*r_gizmo_handle=idx;
|
|
return true;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
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();
|
|
|
|
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<5) {
|
|
|
|
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();
|
|
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 1
|
|
|
|
|
|
|
|
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;
|
|
}
|
|
#else
|
|
|
|
if (collision_mesh->intersect_segment(ray_from,ray_from+ray_dir*4906.0,rpos,rnorm)) {
|
|
|
|
r_pos=gt.xform(rpos);
|
|
r_normal=gt.basis.xform(rnorm).normalized();
|
|
return true;
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SpatialGizmoTool::create() {
|
|
|
|
ERR_FAIL_COND(!spatial_node);
|
|
ERR_FAIL_COND(valid);
|
|
valid=true;
|
|
|
|
for(int i=0;i<instances.size();i++) {
|
|
|
|
instances[i].create_instance(spatial_node);
|
|
}
|
|
|
|
transform();
|
|
|
|
}
|
|
|
|
void SpatialGizmoTool::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 SpatialGizmoTool::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[i].instance=RID();
|
|
}
|
|
|
|
valid=false;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
SpatialGizmoTool::SpatialGizmoTool() {
|
|
valid=false;
|
|
billboard_handle=false;
|
|
|
|
}
|
|
|
|
SpatialGizmoTool::~SpatialGizmoTool(){
|
|
|
|
clear();
|
|
}
|
|
|
|
Vector3 SpatialGizmoTool::get_handle_pos(int p_idx) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_idx,handles.size(),Vector3());
|
|
|
|
return handles[p_idx];
|
|
|
|
}
|
|
|
|
//// light gizmo
|
|
|
|
|
|
String LightSpatialGizmo::get_handle_name(int p_idx) const {
|
|
|
|
if (p_idx==0)
|
|
return "Radius";
|
|
else
|
|
return "Aperture";
|
|
}
|
|
|
|
|
|
Variant LightSpatialGizmo::get_handle_value(int p_idx) const{
|
|
|
|
if (p_idx==0)
|
|
return light->get_parameter(Light::PARAM_RADIUS);
|
|
if (p_idx==1)
|
|
return light->get_parameter(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 = Vector2(min_p.x,-min_p.z).atan2();
|
|
return a*180.0/Math_PI;
|
|
}
|
|
|
|
|
|
void LightSpatialGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_point) {
|
|
|
|
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 (light->cast_to<SpotLight>()) {
|
|
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 (d<0)
|
|
d=0;
|
|
|
|
light->set_parameter(Light::PARAM_RADIUS,d);
|
|
} else if (light->cast_to<OmniLight>()) {
|
|
|
|
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);
|
|
light->set_parameter(Light::PARAM_RADIUS,r);
|
|
}
|
|
|
|
}
|
|
|
|
} else if (p_idx==1) {
|
|
|
|
float a = _find_closest_angle_to_half_pi_arc(s[0],s[1],light->get_parameter(Light::PARAM_RADIUS),gt);
|
|
light->set_parameter(Light::PARAM_SPOT_ANGLE,CLAMP(a,0.01,89.99));
|
|
}
|
|
}
|
|
|
|
void LightSpatialGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_cancel){
|
|
|
|
if (p_cancel) {
|
|
|
|
light->set_parameter(p_idx==0?Light::PARAM_RADIUS:Light::PARAM_SPOT_ANGLE,p_restore);
|
|
|
|
} else if (p_idx==0) {
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action("Change Light Radius");
|
|
ur->add_do_method(light,"set_parameter",Light::PARAM_RADIUS,light->get_parameter(Light::PARAM_RADIUS));
|
|
ur->add_undo_method(light,"set_parameter",Light::PARAM_RADIUS,p_restore);
|
|
ur->commit_action();
|
|
} else if (p_idx==1) {
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action("Change Light Radius");
|
|
ur->add_do_method(light,"set_parameter",Light::PARAM_SPOT_ANGLE,light->get_parameter(Light::PARAM_SPOT_ANGLE));
|
|
ur->add_undo_method(light,"set_parameter",Light::PARAM_SPOT_ANGLE,p_restore);
|
|
ur->commit_action();
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void LightSpatialGizmo::redraw() {
|
|
|
|
|
|
if (light->cast_to<DirectionalLight>()) {
|
|
|
|
|
|
|
|
const int arrow_points=5;
|
|
Vector3 arrow[arrow_points]={
|
|
Vector3(0,0,2),
|
|
Vector3(1,1,2),
|
|
Vector3(1,1,-1),
|
|
Vector3(2,2,-1),
|
|
Vector3(0,0,-3)
|
|
};
|
|
|
|
int arrow_sides=4;
|
|
|
|
Vector<Vector3> lines;
|
|
|
|
|
|
for(int i = 0; i < arrow_sides ; i++) {
|
|
|
|
|
|
Matrix3 ma(Vector3(0,0,1),Math_PI*2*float(i)/arrow_sides);
|
|
Matrix3 mb(Vector3(0,0,1),Math_PI*2*float(i+1)/arrow_sides);
|
|
|
|
|
|
for(int j=1;j<arrow_points-1;j++) {
|
|
|
|
if (j!=2) {
|
|
lines.push_back(ma.xform(arrow[j]));
|
|
lines.push_back(ma.xform(arrow[j+1]));
|
|
}
|
|
if (j<arrow_points-1) {
|
|
lines.push_back(ma.xform(arrow[j]));
|
|
lines.push_back(mb.xform(arrow[j]));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
add_lines(lines,SpatialEditorGizmos::singleton->light_material);
|
|
add_collision_segments(lines);
|
|
add_unscaled_billboard(SpatialEditorGizmos::singleton->light_material_directional_icon,0.05);
|
|
|
|
}
|
|
|
|
if (light->cast_to<OmniLight>()) {
|
|
|
|
clear();
|
|
|
|
|
|
OmniLight *on = light->cast_to<OmniLight>();
|
|
|
|
float r = on->get_parameter(Light::PARAM_RADIUS);
|
|
|
|
Vector<Vector3> points;
|
|
|
|
for(int i=0;i<=360;i++) {
|
|
|
|
float ra=Math::deg2rad(i);
|
|
float rb=Math::deg2rad(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));
|
|
|
|
}
|
|
|
|
add_lines(points,SpatialEditorGizmos::singleton->light_material,true);
|
|
|
|
add_unscaled_billboard(SpatialEditorGizmos::singleton->light_material_omni_icon,0.05);
|
|
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(r,0,0));
|
|
add_handles(handles,true);
|
|
|
|
|
|
}
|
|
|
|
|
|
if (light->cast_to<SpotLight>()) {
|
|
|
|
clear();
|
|
|
|
Vector<Vector3> points;
|
|
SpotLight *on = light->cast_to<SpotLight>();
|
|
|
|
float r = on->get_parameter(Light::PARAM_RADIUS);
|
|
float w = r*Math::sin(Math::deg2rad(on->get_parameter(Light::PARAM_SPOT_ANGLE)));
|
|
float d = r*Math::cos(Math::deg2rad(on->get_parameter(Light::PARAM_SPOT_ANGLE)));
|
|
|
|
|
|
|
|
for(int i=0;i<360;i++) {
|
|
|
|
float ra=Math::deg2rad(i);
|
|
float rb=Math::deg2rad(i+1);
|
|
Point2 a = Vector2(Math::sin(ra),Math::cos(ra))*w;
|
|
Point2 b = Vector2(Math::sin(rb),Math::cos(rb))*w;
|
|
|
|
/*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,-d));
|
|
points.push_back(Vector3(b.x,b.y,-d));
|
|
|
|
if (i%90==0) {
|
|
|
|
points.push_back(Vector3(a.x,a.y,-d));
|
|
points.push_back(Vector3());
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
points.push_back(Vector3(0,0,-r));
|
|
points.push_back(Vector3());
|
|
|
|
add_lines(points,SpatialEditorGizmos::singleton->light_material);
|
|
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(0,0,-r));
|
|
|
|
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))*w;
|
|
Point2 b = Vector2(Math::sin(rb),Math::cos(rb))*w;
|
|
|
|
collision_segments.push_back(Vector3(a.x,a.y,-d));
|
|
collision_segments.push_back(Vector3(b.x,b.y,-d));
|
|
|
|
if (i%16==0) {
|
|
|
|
collision_segments.push_back(Vector3(a.x,a.y,-d));
|
|
collision_segments.push_back(Vector3());
|
|
|
|
}
|
|
|
|
if (i==16) {
|
|
|
|
handles.push_back(Vector3(a.x,a.y,-d));
|
|
}
|
|
|
|
}
|
|
|
|
collision_segments.push_back(Vector3(0,0,-r));
|
|
collision_segments.push_back(Vector3());
|
|
|
|
|
|
add_handles(handles);
|
|
add_collision_segments(collision_segments);
|
|
add_unscaled_billboard(SpatialEditorGizmos::singleton->light_material_omni_icon,0.05);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
LightSpatialGizmo::LightSpatialGizmo(Light* p_light){
|
|
|
|
light=p_light;
|
|
set_spatial_node(p_light);
|
|
|
|
}
|
|
|
|
//////
|
|
|
|
String CameraSpatialGizmo::get_handle_name(int p_idx) const {
|
|
|
|
if (camera->get_projection()==Camera::PROJECTION_PERSPECTIVE) {
|
|
return "FOV";
|
|
} else {
|
|
return "Size";
|
|
}
|
|
}
|
|
Variant CameraSpatialGizmo::get_handle_value(int p_idx) const{
|
|
|
|
if (camera->get_projection()==Camera::PROJECTION_PERSPECTIVE) {
|
|
return camera->get_fov();
|
|
} else {
|
|
|
|
return camera->get_size();
|
|
}
|
|
}
|
|
void CameraSpatialGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_point){
|
|
|
|
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 gt=camera->get_global_transform();
|
|
float a = _find_closest_angle_to_half_pi_arc(s[0],s[1],1.0,gt);
|
|
camera->set("fov",a);
|
|
} 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 (d<0)
|
|
d=0;
|
|
|
|
camera->set("size",d);
|
|
}
|
|
|
|
}
|
|
void CameraSpatialGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_cancel){
|
|
|
|
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("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("Change Camera Size");
|
|
ur->add_do_property(camera,"size",camera->get_size());
|
|
ur->add_undo_property(camera,"size",p_restore);
|
|
ur->commit_action();
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void CameraSpatialGizmo::redraw(){
|
|
|
|
clear();
|
|
|
|
Vector<Vector3> lines;
|
|
Vector<Vector3> handles;
|
|
|
|
|
|
switch(camera->get_projection()) {
|
|
|
|
case Camera::PROJECTION_PERSPECTIVE: {
|
|
|
|
float fov = camera->get_fov();
|
|
|
|
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);
|
|
|
|
|
|
#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);\
|
|
}
|
|
|
|
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: {
|
|
|
|
#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);\
|
|
}
|
|
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;
|
|
|
|
}
|
|
|
|
add_lines(lines,SpatialEditorGizmos::singleton->camera_material);
|
|
add_collision_segments(lines);
|
|
add_handles(handles);
|
|
}
|
|
|
|
|
|
CameraSpatialGizmo::CameraSpatialGizmo(Camera* p_camera){
|
|
|
|
camera=p_camera;
|
|
set_spatial_node(camera);
|
|
}
|
|
|
|
|
|
|
|
|
|
//////
|
|
|
|
void MeshInstanceSpatialGizmo::redraw() {
|
|
|
|
Ref<Mesh> m = mesh->get_mesh();
|
|
if (!m.is_valid())
|
|
return; //none
|
|
|
|
Ref<TriangleMesh> tm = m->generate_triangle_mesh();
|
|
if (tm.is_valid())
|
|
add_collision_triangles(tm);
|
|
}
|
|
|
|
MeshInstanceSpatialGizmo::MeshInstanceSpatialGizmo(MeshInstance* p_mesh) {
|
|
|
|
mesh=p_mesh;
|
|
set_spatial_node(p_mesh);
|
|
}
|
|
|
|
/////
|
|
|
|
|
|
void Position3DSpatialGizmo::redraw() {
|
|
|
|
clear();
|
|
add_mesh(SpatialEditorGizmos::singleton->pos3d_mesh);
|
|
Vector<Vector3> cursor_points;
|
|
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));
|
|
add_collision_segments(cursor_points);
|
|
|
|
}
|
|
|
|
|
|
Position3DSpatialGizmo::Position3DSpatialGizmo(Position3D* p_p3d) {
|
|
|
|
p3d=p_p3d;
|
|
set_spatial_node(p3d);
|
|
}
|
|
|
|
|
|
/////
|
|
|
|
void SkeletonSpatialGizmo::redraw() {
|
|
|
|
clear();
|
|
|
|
Ref<SurfaceTool> surface_tool( memnew( SurfaceTool ));
|
|
|
|
|
|
surface_tool->begin(Mesh::PRIMITIVE_LINES);
|
|
surface_tool->set_material(SpatialEditorGizmos::singleton->skeleton_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[i]=0;
|
|
weights[i]=0;
|
|
}
|
|
|
|
weights[0]=1;
|
|
|
|
|
|
|
|
for (int i=0;i<skel->get_bone_count();i++) {
|
|
|
|
int parent = skel->get_bone_parent(i);
|
|
|
|
if (parent>=0) {
|
|
grests[i]=grests[parent] * skel->get_bone_rest(i);
|
|
|
|
Vector3 v0 = grests[parent].origin;
|
|
Vector3 v1 = grests[i].origin;
|
|
|
|
|
|
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[i]=skel->get_bone_rest(i);
|
|
bones[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<Mesh> m = surface_tool->commit();
|
|
add_mesh(m,false,skel->get_skeleton());
|
|
|
|
}
|
|
|
|
SkeletonSpatialGizmo::SkeletonSpatialGizmo(Skeleton* p_skel) {
|
|
|
|
skel=p_skel;
|
|
set_spatial_node(p_skel);
|
|
}
|
|
|
|
/////
|
|
|
|
|
|
void SpatialPlayerSpatialGizmo::redraw() {
|
|
|
|
clear();
|
|
if (splayer->cast_to<SpatialStreamPlayer>()) {
|
|
|
|
add_unscaled_billboard(SpatialEditorGizmos::singleton->stream_player_icon,0.05);
|
|
|
|
} else if (splayer->cast_to<SpatialSamplePlayer>()) {
|
|
|
|
add_unscaled_billboard(SpatialEditorGizmos::singleton->sample_player_icon,0.05);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SpatialPlayerSpatialGizmo::SpatialPlayerSpatialGizmo(SpatialPlayer* p_splayer){
|
|
|
|
set_spatial_node(p_splayer);
|
|
splayer=p_splayer;
|
|
}
|
|
|
|
|
|
/////
|
|
|
|
|
|
void RoomSpatialGizmo::redraw() {
|
|
|
|
clear();
|
|
Ref<RoomBounds> roomie = room->get_room();
|
|
if (roomie.is_null())
|
|
return;
|
|
DVector<Face3> faces = roomie->get_geometry_hint();
|
|
|
|
Vector<Vector3> lines;
|
|
int fc=faces.size();
|
|
DVector<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(CMP_EPSILON);
|
|
ek.to=r[i].vertex[(j+1)%3].snapped(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,SpatialEditorGizmos::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,SpatialEditorGizmos::singleton->portal_material);
|
|
add_collision_segments(lines);
|
|
|
|
}
|
|
|
|
PortalSpatialGizmo::PortalSpatialGizmo(Portal* p_portal){
|
|
|
|
set_spatial_node(p_portal);
|
|
portal=p_portal;
|
|
}
|
|
|
|
/////
|
|
|
|
|
|
void RayCastSpatialGizmo::redraw() {
|
|
|
|
clear();
|
|
|
|
|
|
Vector<Vector3> lines;
|
|
|
|
lines.push_back(Vector3());
|
|
lines.push_back(raycast->get_cast_to());
|
|
|
|
add_lines(lines,SpatialEditorGizmos::singleton->raycast_material);
|
|
add_collision_segments(lines);
|
|
|
|
}
|
|
|
|
RayCastSpatialGizmo::RayCastSpatialGizmo(RayCast* p_raycast){
|
|
|
|
set_spatial_node(p_raycast);
|
|
raycast=p_raycast;
|
|
}
|
|
|
|
|
|
/////
|
|
|
|
|
|
void CarWheelSpatialGizmo::redraw() {
|
|
|
|
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(i);
|
|
float rb=Math::deg2rad(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_travel()*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_travel(),0));
|
|
|
|
//axis
|
|
points.push_back(Vector3(r*0.2,car_wheel->get_travel(),0));
|
|
points.push_back(Vector3(-r*0.2,car_wheel->get_travel(),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));
|
|
|
|
add_lines(points,SpatialEditorGizmos::singleton->car_wheel_material);
|
|
add_collision_segments(points);
|
|
|
|
}
|
|
|
|
CarWheelSpatialGizmo::CarWheelSpatialGizmo(CarWheel* p_car_wheel){
|
|
|
|
set_spatial_node(p_car_wheel);
|
|
car_wheel=p_car_wheel;
|
|
}
|
|
|
|
|
|
|
|
///
|
|
|
|
void TestCubeSpatialGizmo::redraw() {
|
|
|
|
clear();
|
|
add_collision_triangles(SpatialEditorGizmos::singleton->test_cube_tm);
|
|
}
|
|
|
|
TestCubeSpatialGizmo::TestCubeSpatialGizmo(TestCube* p_tc) {
|
|
|
|
tc=p_tc;
|
|
set_spatial_node(p_tc);
|
|
}
|
|
|
|
|
|
///////////
|
|
|
|
|
|
|
|
|
|
|
|
|
|
String CollisionShapeSpatialGizmo::get_handle_name(int p_idx) const {
|
|
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return "";
|
|
|
|
if (s->cast_to<SphereShape>()) {
|
|
|
|
return "Radius";
|
|
}
|
|
|
|
if (s->cast_to<BoxShape>()) {
|
|
|
|
return "Extents";
|
|
}
|
|
|
|
if (s->cast_to<CapsuleShape>()) {
|
|
|
|
return p_idx==0?"Radius":"Height";
|
|
}
|
|
|
|
if (s->cast_to<RayShape>()) {
|
|
|
|
return "Length";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
Variant CollisionShapeSpatialGizmo::get_handle_value(int p_idx) const{
|
|
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return Variant();
|
|
|
|
if (s->cast_to<SphereShape>()) {
|
|
|
|
Ref<SphereShape> ss = s;
|
|
return ss->get_radius();
|
|
}
|
|
|
|
if (s->cast_to<BoxShape>()) {
|
|
|
|
Ref<BoxShape> bs = s;
|
|
return bs->get_extents();
|
|
}
|
|
|
|
if (s->cast_to<CapsuleShape>()) {
|
|
|
|
Ref<CapsuleShape> cs = s;
|
|
return p_idx==0?cs->get_radius():cs->get_height();
|
|
}
|
|
|
|
if (s->cast_to<RayShape>()) {
|
|
|
|
Ref<RayShape> cs = s;
|
|
return cs->get_length();
|
|
}
|
|
|
|
return Variant();
|
|
}
|
|
void CollisionShapeSpatialGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_point){
|
|
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 (s->cast_to<SphereShape>()) {
|
|
|
|
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 (d<0.001)
|
|
d=0.001;
|
|
|
|
ss->set_radius(d);
|
|
}
|
|
|
|
if (s->cast_to<RayShape>()) {
|
|
|
|
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 (d<0.001)
|
|
d=0.001;
|
|
|
|
rs->set_length(d);
|
|
}
|
|
|
|
|
|
if (s->cast_to<BoxShape>()) {
|
|
|
|
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 (d<0.001)
|
|
d=0.001;
|
|
|
|
Vector3 he = bs->get_extents();
|
|
he[p_idx]=d;
|
|
bs->set_extents(he);
|
|
|
|
}
|
|
|
|
if (s->cast_to<CapsuleShape>()) {
|
|
|
|
Vector3 axis;
|
|
axis[p_idx==0?0:2]=1.0;
|
|
Ref<CapsuleShape> cs = 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 (p_idx==1)
|
|
d-=cs->get_radius();
|
|
if (d<0.001)
|
|
d=0.001;
|
|
|
|
if (p_idx==0)
|
|
cs->set_radius(d);
|
|
else if (p_idx==1)
|
|
cs->set_height(d*2.0);
|
|
|
|
}
|
|
|
|
}
|
|
void CollisionShapeSpatialGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_cancel){
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return;
|
|
|
|
if (s->cast_to<SphereShape>()) {
|
|
|
|
Ref<SphereShape> ss=s;
|
|
if (p_cancel) {
|
|
ss->set_radius(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action("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 (s->cast_to<BoxShape>()) {
|
|
|
|
Ref<BoxShape> ss=s;
|
|
if (p_cancel) {
|
|
ss->set_extents(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action("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 (s->cast_to<CapsuleShape>()) {
|
|
|
|
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("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("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 (s->cast_to<RayShape>()) {
|
|
|
|
Ref<RayShape> ss=s;
|
|
if (p_cancel) {
|
|
ss->set_length(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action("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 CollisionShapeSpatialGizmo::redraw(){
|
|
|
|
clear();
|
|
|
|
Ref<Shape> s = cs->get_shape();
|
|
if (s.is_null())
|
|
return;
|
|
|
|
if (s->cast_to<SphereShape>()) {
|
|
|
|
Ref<SphereShape> sp= s;
|
|
float r=sp->get_radius();
|
|
|
|
Vector<Vector3> points;
|
|
|
|
for(int i=0;i<=360;i++) {
|
|
|
|
float ra=Math::deg2rad(i);
|
|
float rb=Math::deg2rad(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));
|
|
}
|
|
|
|
add_lines(points,SpatialEditorGizmos::singleton->shape_material);
|
|
add_collision_segments(collision_segments);
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(r,0,0));
|
|
add_handles(handles);
|
|
|
|
}
|
|
|
|
if (s->cast_to<BoxShape>()) {
|
|
|
|
Ref<BoxShape> bs=s;
|
|
Vector<Vector3> lines;
|
|
AABB aabb;
|
|
aabb.pos=-bs->get_extents();
|
|
aabb.size=aabb.pos*-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);
|
|
}
|
|
|
|
add_lines(lines,SpatialEditorGizmos::singleton->shape_material);
|
|
add_collision_segments(lines);
|
|
add_handles(handles);
|
|
|
|
}
|
|
|
|
if (s->cast_to<CapsuleShape>()) {
|
|
|
|
Ref<CapsuleShape> cs=s;
|
|
float radius = cs->get_radius();
|
|
float height = cs->get_height();
|
|
|
|
|
|
Vector<Vector3> points;
|
|
|
|
Vector3 d(0,0,height*0.5);
|
|
for(int i=0;i<360;i++) {
|
|
|
|
float ra=Math::deg2rad(i);
|
|
float rb=Math::deg2rad(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);
|
|
|
|
}
|
|
|
|
add_lines(points,SpatialEditorGizmos::singleton->shape_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);
|
|
|
|
}
|
|
|
|
add_collision_segments(collision_segments);
|
|
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(cs->get_radius(),0,0));
|
|
handles.push_back(Vector3(0,0,cs->get_height()*0.5+cs->get_radius()));
|
|
add_handles(handles);
|
|
|
|
|
|
}
|
|
|
|
if (s->cast_to<PlaneShape>()) {
|
|
|
|
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);
|
|
|
|
add_lines(points,SpatialEditorGizmos::singleton->shape_material);
|
|
add_collision_segments(points);
|
|
|
|
}
|
|
|
|
|
|
if (s->cast_to<RayShape>()) {
|
|
|
|
Ref<RayShape> rs=s;
|
|
|
|
Vector<Vector3> points;
|
|
points.push_back(Vector3());
|
|
points.push_back(Vector3(0,0,rs->get_length()));
|
|
add_lines(points,SpatialEditorGizmos::singleton->shape_material);
|
|
add_collision_segments(points);
|
|
Vector<Vector3> handles;
|
|
handles.push_back(Vector3(0,0,rs->get_length()));
|
|
add_handles(handles);
|
|
|
|
|
|
}
|
|
|
|
}
|
|
CollisionShapeSpatialGizmo::CollisionShapeSpatialGizmo(CollisionShape* p_cs) {
|
|
|
|
cs=p_cs;
|
|
set_spatial_node(p_cs);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
String VisibilityNotifierGizmo::get_handle_name(int p_idx) const {
|
|
|
|
switch(p_idx) {
|
|
case 0: return "X";
|
|
case 1: return "Y";
|
|
case 2: return "Z";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
Variant VisibilityNotifierGizmo::get_handle_value(int p_idx) const{
|
|
|
|
return notifier->get_aabb();
|
|
}
|
|
void VisibilityNotifierGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_point){
|
|
|
|
|
|
Transform gt = notifier->get_global_transform();
|
|
//gt.orthonormalize();
|
|
Transform gi = gt.affine_inverse();
|
|
|
|
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.pos+aabb.size*0.5;;
|
|
|
|
Vector3 axis;
|
|
axis[p_idx]=1.0;
|
|
|
|
Vector3 ra,rb;
|
|
Geometry::get_closest_points_between_segments(ofs,ofs+axis*4096,sg[0],sg[1],ra,rb);
|
|
float d = ra[p_idx];
|
|
if (d<0.001)
|
|
d=0.001;
|
|
|
|
Vector3 he = aabb.size;
|
|
aabb.pos[p_idx]=(aabb.pos[p_idx]+aabb.size[p_idx]*0.5)-d;
|
|
aabb.size[p_idx]=d*2;
|
|
notifier->set_aabb(aabb);
|
|
}
|
|
|
|
void VisibilityNotifierGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_cancel){
|
|
|
|
|
|
if (p_cancel) {
|
|
notifier->set_aabb(p_restore);
|
|
return;
|
|
}
|
|
|
|
UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
|
|
ur->create_action("Change Notifier Extents");
|
|
ur->add_do_method(notifier,"set_aabb",notifier->get_aabb());
|
|
ur->add_undo_method(notifier,"set_aabb",p_restore);
|
|
ur->commit_action();
|
|
|
|
}
|
|
|
|
void VisibilityNotifierGizmo::redraw(){
|
|
|
|
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.pos[i]+aabb.size[i];
|
|
handles.push_back(ax);
|
|
}
|
|
|
|
add_lines(lines,SpatialEditorGizmos::singleton->visibility_notifier_material);
|
|
//add_unscaled_billboard(SpatialEditorGizmos::singleton->visi,0.05);
|
|
add_collision_segments(lines);
|
|
add_handles(handles);
|
|
|
|
}
|
|
VisibilityNotifierGizmo::VisibilityNotifierGizmo(VisibilityNotifier* p_notifier){
|
|
|
|
notifier=p_notifier;
|
|
set_spatial_node(p_notifier);
|
|
}
|
|
|
|
|
|
|
|
////////
|
|
SpatialEditorGizmos *SpatialEditorGizmos::singleton=NULL;
|
|
|
|
Ref<SpatialEditorGizmo> SpatialEditorGizmos::get_gizmo(Spatial *p_spatial) {
|
|
|
|
if (p_spatial->cast_to<Light>()) {
|
|
|
|
Ref<LightSpatialGizmo> lsg = memnew( LightSpatialGizmo(p_spatial->cast_to<Light>()) );
|
|
return lsg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<Camera>()) {
|
|
|
|
Ref<CameraSpatialGizmo> lsg = memnew( CameraSpatialGizmo(p_spatial->cast_to<Camera>()) );
|
|
return lsg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<Skeleton>()) {
|
|
|
|
Ref<SkeletonSpatialGizmo> lsg = memnew( SkeletonSpatialGizmo(p_spatial->cast_to<Skeleton>()) );
|
|
return lsg;
|
|
}
|
|
|
|
|
|
if (p_spatial->cast_to<Position3D>()) {
|
|
|
|
Ref<Position3DSpatialGizmo> lsg = memnew( Position3DSpatialGizmo(p_spatial->cast_to<Position3D>()) );
|
|
return lsg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<MeshInstance>()) {
|
|
|
|
Ref<MeshInstanceSpatialGizmo> misg = memnew( MeshInstanceSpatialGizmo(p_spatial->cast_to<MeshInstance>()) );
|
|
return misg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<Room>()) {
|
|
|
|
Ref<RoomSpatialGizmo> misg = memnew( RoomSpatialGizmo(p_spatial->cast_to<Room>()) );
|
|
return misg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<RayCast>()) {
|
|
|
|
Ref<RayCastSpatialGizmo> misg = memnew( RayCastSpatialGizmo(p_spatial->cast_to<RayCast>()) );
|
|
return misg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<Portal>()) {
|
|
|
|
Ref<PortalSpatialGizmo> misg = memnew( PortalSpatialGizmo(p_spatial->cast_to<Portal>()) );
|
|
return misg;
|
|
}
|
|
|
|
|
|
if (p_spatial->cast_to<TestCube>()) {
|
|
|
|
Ref<TestCubeSpatialGizmo> misg = memnew( TestCubeSpatialGizmo(p_spatial->cast_to<TestCube>()) );
|
|
return misg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<SpatialPlayer>()) {
|
|
|
|
Ref<SpatialPlayerSpatialGizmo> misg = memnew( SpatialPlayerSpatialGizmo(p_spatial->cast_to<SpatialPlayer>()) );
|
|
return misg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<CollisionShape>()) {
|
|
|
|
Ref<CollisionShapeSpatialGizmo> misg = memnew( CollisionShapeSpatialGizmo(p_spatial->cast_to<CollisionShape>()) );
|
|
return misg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<VisibilityNotifier>()) {
|
|
|
|
Ref<VisibilityNotifierGizmo> misg = memnew( VisibilityNotifierGizmo(p_spatial->cast_to<VisibilityNotifier>()) );
|
|
return misg;
|
|
}
|
|
|
|
if (p_spatial->cast_to<EditableShape>()) {
|
|
|
|
Ref<EditableShapeSpatialGizmo> misg = memnew( EditableShapeSpatialGizmo(p_spatial->cast_to<EditableShape>()) );
|
|
return misg;
|
|
}
|
|
if (p_spatial->cast_to<CarWheel>()) {
|
|
|
|
Ref<CarWheelSpatialGizmo> misg = memnew( CarWheelSpatialGizmo(p_spatial->cast_to<CarWheel>()) );
|
|
return misg;
|
|
}
|
|
|
|
return Ref<SpatialEditorGizmo>();
|
|
}
|
|
|
|
SpatialEditorGizmos::SpatialEditorGizmos() {
|
|
|
|
singleton=this;
|
|
|
|
handle_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
handle_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
handle_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(0.8,0.8,0.8));
|
|
|
|
handle2_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
handle2_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
handle2_material->set_fixed_flag(FixedMaterial::FLAG_USE_POINT_SIZE, true);
|
|
handle_t = SpatialEditor::get_singleton()->get_icon("Editor3DHandle","EditorIcons");
|
|
handle2_material->set_point_size(handle_t->get_width());
|
|
handle2_material->set_texture(FixedMaterial::PARAM_DIFFUSE,handle_t);
|
|
handle2_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,1));
|
|
handle2_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
|
|
light_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
light_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
light_material->set_line_width(3.0);
|
|
light_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
light_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,0.2,0.3));
|
|
|
|
light_material_omni_icon = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
light_material_omni_icon->set_flag(Material::FLAG_UNSHADED, true);
|
|
light_material_omni_icon->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
light_material_omni_icon->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
light_material_omni_icon->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
light_material_omni_icon->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,1,0.9));
|
|
light_material_omni_icon->set_texture(FixedMaterial::PARAM_DIFFUSE,SpatialEditor::get_singleton()->get_icon("GizmoLight","EditorIcons"));
|
|
|
|
|
|
light_material_directional_icon = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
light_material_directional_icon->set_flag(Material::FLAG_UNSHADED, true);
|
|
light_material_directional_icon->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
light_material_directional_icon->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
light_material_directional_icon->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
light_material_directional_icon->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,1,0.9));
|
|
light_material_directional_icon->set_texture(FixedMaterial::PARAM_DIFFUSE,SpatialEditor::get_singleton()->get_icon("GizmoDirectionalLight","EditorIcons"));
|
|
|
|
camera_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
camera_material->set_parameter( FixedMaterial::PARAM_DIFFUSE,Color(1.0,0.5,1.0,0.7) );
|
|
camera_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
camera_material->set_line_width(3);
|
|
camera_material->set_flag(Material::FLAG_DOUBLE_SIDED,true);
|
|
camera_material->set_flag(Material::FLAG_UNSHADED,true);
|
|
camera_material->set_hint(Material::HINT_NO_DEPTH_DRAW,true);
|
|
|
|
|
|
|
|
skeleton_material=Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
|
|
//skeleton_material->set_parameter( FixedMaterial::PARAM_DIFFUSE,Color(0.6,1.0,0.3,0.1) );
|
|
skeleton_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
skeleton_material->set_fixed_flag(FixedMaterial::FLAG_USE_COLOR_ARRAY, true);
|
|
skeleton_material->set_line_width(3);
|
|
skeleton_material->set_flag(Material::FLAG_DOUBLE_SIDED,true);
|
|
skeleton_material->set_flag(Material::FLAG_UNSHADED,true);
|
|
skeleton_material->set_flag(Material::FLAG_ONTOP,true);
|
|
skeleton_material->set_hint(Material::HINT_NO_DEPTH_DRAW,true);
|
|
|
|
//position 3D Shared mesh
|
|
|
|
pos3d_mesh = Ref<Mesh>( memnew( Mesh ) );
|
|
{
|
|
|
|
DVector<Vector3> cursor_points;
|
|
DVector<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<FixedMaterial> mat = memnew( FixedMaterial );
|
|
mat->set_flag(Material::FLAG_UNSHADED,true);
|
|
mat->set_fixed_flag(FixedMaterial::FLAG_USE_COLOR_ARRAY,true);
|
|
mat->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA,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(Mesh::PRIMITIVE_LINES,d);
|
|
pos3d_mesh->surface_set_material(0,mat);
|
|
}
|
|
|
|
|
|
sample_player_icon = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
sample_player_icon->set_flag(Material::FLAG_UNSHADED, true);
|
|
sample_player_icon->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
sample_player_icon->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
sample_player_icon->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
sample_player_icon->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,1,0.9));
|
|
sample_player_icon->set_texture(FixedMaterial::PARAM_DIFFUSE,SpatialEditor::get_singleton()->get_icon("GizmoSpatialSamplePlayer","EditorIcons"));
|
|
|
|
room_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
room_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
room_material->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
//room_material->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
room_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
room_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1.0,0.6,0.9,0.8));
|
|
room_material->set_line_width(3);
|
|
|
|
portal_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
portal_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
portal_material->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
//portal_material->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
portal_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
portal_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1.0,0.8,0.6,0.8));
|
|
portal_material->set_line_width(3);
|
|
|
|
|
|
raycast_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
raycast_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
raycast_material->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
//raycast_material->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
raycast_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
raycast_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1.0,0.8,0.6,0.8));
|
|
raycast_material->set_line_width(3);
|
|
|
|
car_wheel_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
car_wheel_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
car_wheel_material->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
//car_wheel_material->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
car_wheel_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
car_wheel_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(0.6,0.8,1.0,0.8));
|
|
car_wheel_material->set_line_width(3);
|
|
|
|
|
|
|
|
visibility_notifier_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
visibility_notifier_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
visibility_notifier_material->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
//visibility_notifier_material->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
visibility_notifier_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
visibility_notifier_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1.0,0.5,1.0,0.8));
|
|
visibility_notifier_material->set_line_width(3);
|
|
|
|
stream_player_icon = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
stream_player_icon->set_flag(Material::FLAG_UNSHADED, true);
|
|
stream_player_icon->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
stream_player_icon->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
stream_player_icon->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
stream_player_icon->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,1,0.9));
|
|
stream_player_icon->set_texture(FixedMaterial::PARAM_DIFFUSE,SpatialEditor::get_singleton()->get_icon("GizmoSpatialStreamPlayer","EditorIcons"));
|
|
|
|
visibility_notifier_icon = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
visibility_notifier_icon->set_flag(Material::FLAG_UNSHADED, true);
|
|
visibility_notifier_icon->set_flag(Material::FLAG_DOUBLE_SIDED, true);
|
|
visibility_notifier_icon->set_hint(Material::HINT_NO_DEPTH_DRAW, true);
|
|
visibility_notifier_icon->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
visibility_notifier_icon->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,1,0.9));
|
|
visibility_notifier_icon->set_texture(FixedMaterial::PARAM_DIFFUSE,SpatialEditor::get_singleton()->get_icon("Visible","EditorIcons"));
|
|
|
|
{
|
|
|
|
DVector<Vector3> vertices;
|
|
|
|
#undef ADD_VTX
|
|
#define ADD_VTX(m_idx);\
|
|
vertices.push_back( face_points[m_idx] );
|
|
|
|
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);
|
|
}
|
|
}
|
|
//tri 1
|
|
ADD_VTX(0);
|
|
ADD_VTX(1);
|
|
ADD_VTX(2);
|
|
//tri 2
|
|
ADD_VTX(2);
|
|
ADD_VTX(3);
|
|
ADD_VTX(0);
|
|
|
|
}
|
|
|
|
test_cube_tm = Ref<TriangleMesh>( memnew( TriangleMesh ) );
|
|
test_cube_tm->create(vertices);
|
|
}
|
|
|
|
|
|
shape_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
|
|
shape_material->set_flag(Material::FLAG_UNSHADED, true);
|
|
shape_material->set_line_width(3.0);
|
|
shape_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
|
|
shape_material->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(0.2,1,1.0,0.3));
|
|
|
|
}
|