Vector3 Camera::project_local_ray_normal(const Point2& p_pos) const {
if (!is_inside_scene()) {
ERR_EXPLAIN("Camera is not inside scene.");
ERR_FAIL_COND_V(!is_inside_scene(),Vector3());
}
Size2 viewport_size = viewport_ptr->get_visible_rect().size;
Vector3 ray;
if (mode==PROJECTION_ORTHOGONAL) {
ray=Vector3(0,0,-1);
} else {
CameraMatrix cm;
cm.set_perspective(fov,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH);
float screen_w,screen_h;
cm.get_viewport_size(screen_w,screen_h);
ray=Vector3( ((p_pos.x/viewport_size.width)*2.0-1.0)*screen_w, ((1.0-(p_pos.y/viewport_size.height))*2.0-1.0)*screen_h,-near).normalized();
}
return ray;
};
Point2 Camera::unproject_position(const Vector3& p_pos) const {
if (!is_inside_scene()) {
ERR_EXPLAIN("Camera is not inside scene.");
ERR_FAIL_COND_V(!is_inside_scene(),Vector2());
}
Size2 viewport_size = viewport_ptr->get_visible_rect().size;
CameraMatrix cm;
if (mode==PROJECTION_ORTHOGONAL)
cm.set_orthogonal(size,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH);
else
cm.set_perspective(fov,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH);
Plane p(get_camera_transform().xform_inv(p_pos),1.0);
p=cm.xform4(p);
p.normal/=p.d;
Point2 res;
res.x = (p.normal.x * 0.5 + 0.5) * viewport_size.x;
res.y = (-p.normal.y * 0.5 + 0.5) * viewport_size.y;
return res;
}
void ScrollBar::set_drag_slave(const NodePath& p_path) {
if (is_inside_scene()) {
if (drag_slave) {
drag_slave->disconnect("input_event",this,"_drag_slave_input");
drag_slave->disconnect("exit_scene",this,"_drag_slave_exit");
}
}
drag_slave=NULL;
drag_slave_path=p_path;
if (is_inside_scene()) {
if (has_node(p_path)) {
Node *n = get_node(p_path);
drag_slave=n->cast_to<Control>();
}
if (drag_slave) {
drag_slave->connect("input_event",this,"_drag_slave_input");
drag_slave->connect("exit_scene",this,"_drag_slave_exit",varray(),CONNECT_ONESHOT);
}
}
}
void Viewport::set_world(const Ref<World>& p_world) {
if (world==p_world)
return;
if (is_inside_scene())
_propagate_exit_world(this);
#ifndef _3D_DISABLED
if (find_world().is_valid() && camera)
camera->notification(Camera::NOTIFICATION_LOST_CURRENT);
#endif
world=p_world;
if (is_inside_scene())
_propagate_enter_world(this);
#ifndef _3D_DISABLED
if (find_world().is_valid() && camera)
camera->notification(Camera::NOTIFICATION_BECAME_CURRENT);
#endif
//propagate exit
if (is_inside_scene()) {
VisualServer::get_singleton()->viewport_set_scenario(viewport,find_world()->get_scenario());
}
_update_listener();
}
Vector3 Camera::project_position(const Point2& p_point) const {
if (!is_inside_scene()) {
ERR_EXPLAIN("Camera is not inside scene.");
ERR_FAIL_COND_V(!is_inside_scene(),Vector3());
}
Size2 viewport_size = viewport_ptr->get_visible_rect().size;
CameraMatrix cm;
if (mode==PROJECTION_ORTHOGONAL)
cm.set_orthogonal(size,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH);
else
cm.set_perspective(fov,viewport_size.get_aspect(),near,far,keep_aspect==KEEP_WIDTH);
Size2 vp_size;
cm.get_viewport_size(vp_size.x,vp_size.y);
Vector2 point;
point.x = (p_point.x/viewport_size.x) * 2.0 - 1.0;
point.y = (p_point.y/viewport_size.y) * 2.0 - 1.0;
point*=vp_size;
Vector3 p(point.x,point.y,-near);
return get_camera_transform().xform(p);
}
bool Camera::_get(const StringName& p_name,Variant &r_ret) const {
if (p_name=="projection") {
r_ret= mode;
} else if (p_name=="fov" || p_name=="fovy" || p_name=="fovx")
r_ret= fov;
else if (p_name=="size" || p_name=="sizex" || p_name=="sizey")
r_ret= size;
else if (p_name=="near")
r_ret= near;
else if (p_name=="far")
r_ret= far;
else if (p_name=="keep_aspect")
r_ret= int(keep_aspect);
else if (p_name=="current") {
if (is_inside_scene() && get_scene()->is_editor_hint()) {
r_ret=current;
} else {
r_ret=is_current();
}
} else if (p_name=="visible_layers") {
r_ret=get_visible_layers();
} else if (p_name=="environment") {
r_ret=get_environment();
} else
return false;
return true;
}
void CollisionPolygon2D::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
if (!is_inside_scene())
break;
_update_parent();
} break;
case NOTIFICATION_DRAW: {
for(int i=0;i<polygon.size();i++) {
Vector2 p = polygon[i];
Vector2 n = polygon[(i+1)%polygon.size()];
draw_line(p,n,Color(0,0.6,0.7,0.5),3);
}
Vector< Vector<Vector2> > decomp = Geometry::decompose_polygon(polygon);
#define DEBUG_DECOMPOSE
#ifdef DEBUG_DECOMPOSE
Color c(0.4,0.9,0.1);
for(int i=0;i<decomp.size();i++) {
c.set_hsv( Math::fmod(c.get_h() + 0.738,1),c.get_s(),c.get_v(),0.5);
draw_colored_polygon(decomp[i],c);
}
#endif
} break;
}
}
void Spatial::_propagate_transform_changed(Spatial *p_origin) {
if (!is_inside_scene()) {
return;
}
// if (data.dirty&DIRTY_GLOBAL)
// return; //already dirty
data.children_lock++;
for (List<Spatial*>::Element *E=data.children.front();E;E=E->next()) {
if (E->get()->data.toplevel_active)
continue; //don't propagate to a toplevel
E->get()->_propagate_transform_changed(p_origin);
}
if (!data.ignore_notification && !xform_change.in_list()) {
get_scene()->xform_change_list.add(&xform_change);
}
data.dirty|=DIRTY_GLOBAL;
data.children_lock--;
}
void Node::set_pause_mode(PauseMode p_mode) {
if (data.pause_mode==p_mode)
return;
bool prev_inherits=data.pause_mode==PAUSE_MODE_INHERIT;
data.pause_mode=p_mode;
if (!is_inside_scene())
return; //pointless
if ((data.pause_mode==PAUSE_MODE_INHERIT) == prev_inherits)
return; ///nothing changed
Node *owner=NULL;
if (data.pause_mode==PAUSE_MODE_INHERIT) {
if (data.parent)
data.parent->data.pause_owner;
} else {
owner=this;
}
_propagate_pause_owner(owner);
}
void Viewport::_update_rect() {
if (!is_inside_scene())
return;
Node *parent = get_parent();
if (!render_target && parent && parent->cast_to<Control>()) {
Control *c = parent->cast_to<Control>();
rect.pos=Point2();
rect.size=c->get_size();
}
VisualServer::ViewportRect vr;
vr.x=rect.pos.x;
vr.y=rect.pos.y;
if (render_target) {
vr.x=0;
vr.y=0;
}
vr.width=rect.size.width;
vr.height=rect.size.height;
VisualServer::get_singleton()->viewport_set_rect(viewport,vr);
if (canvas_item.is_valid()) {
VisualServer::get_singleton()->canvas_item_set_custom_rect(canvas_item,true,rect);
}
emit_signal("size_changed");
render_target_texture->emit_changed();
}
void Viewport::set_as_render_target(bool p_enable){
if (render_target==p_enable)
return;
render_target=p_enable;
VS::get_singleton()->viewport_set_as_render_target(viewport,p_enable);
if (is_inside_scene()) {
if (p_enable)
_vp_exit_scene();
else
_vp_enter_scene();
}
if (p_enable) {
render_target_texture_rid = VS::get_singleton()->viewport_get_render_target_texture(viewport);
} else {
render_target_texture_rid=RID();
}
render_target_texture->set_flags(render_target_texture->flags);
render_target_texture->emit_changed();
}
void RayCast2D::set_cast_to(const Vector2& p_point) {
cast_to=p_point;
if (is_inside_scene() && get_scene()->is_editor_hint())
update();
}
void NavigationMeshInstance::set_enabled(bool p_enabled) {
if (enabled==p_enabled)
return;
enabled=p_enabled;
if (!is_inside_scene())
return;
if (!enabled) {
if (nav_id!=-1) {
navigation->navmesh_remove(nav_id);
nav_id=-1;
}
} else {
if (navigation) {
if (navmesh.is_valid()) {
nav_id = navigation->navmesh_create(navmesh,get_relative_transform(navigation));
}
}
}
update_gizmo();
}
void Camera2D::make_current() {
if (!is_inside_scene()) {
current=true;
} else {
get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,group_name,"_make_current",this);
}
}
Size2 CanvasLayer::get_viewport_size() const {
if (!is_inside_scene())
return Size2(1,1);
Rect2 r = vp->get_visible_rect();
return r.size;
}
void Viewport::_update_listener_2d() {
if (is_inside_scene() && audio_listener_2d)
SpatialSound2DServer::get_singleton()->listener_set_space(listener_2d,find_world_2d()->get_sound_space());
else
SpatialSound2DServer::get_singleton()->listener_set_space(listener_2d,RID());
}
void Skeleton::set_bone_pose(int p_bone, const Transform& p_pose) {
ERR_FAIL_INDEX( p_bone, bones.size() );
ERR_FAIL_COND( !is_inside_scene() );
bones[p_bone].pose=p_pose;
_make_dirty();
}
void RayCast2D::set_enabled(bool p_enabled) {
enabled=p_enabled;
if (is_inside_scene() && !get_scene()->is_editor_hint())
set_fixed_process(p_enabled);
if (!p_enabled)
collided=false;
}
void Container::_sort_children() {
if (!is_inside_scene())
return;
notification(NOTIFICATION_SORT_CHILDREN);
emit_signal(SceneStringNames::get_singleton()->sort_children);
pending_sort=false;
}
int Label::get_line_count() const {
if (!is_inside_scene())
return 1;
if (word_cache_dirty)
const_cast<Label*>(this)->regenerate_word_cache();
return line_count;
}
bool Camera::is_current() const {
if (is_inside_scene()) {
if (viewport_ptr)
return viewport_ptr->get_camera()==this;
} else
return current;
return false;
}
void Viewport::_update_listener() {
if (is_inside_scene() && audio_listener && camera) {
SpatialSoundServer::get_singleton()->listener_set_space(listener,find_world()->get_sound_space());
} else {
SpatialSoundServer::get_singleton()->listener_set_space(listener,RID());
}
}
void ReferenceFrame::_notification(int p_what) {
if (p_what==NOTIFICATION_DRAW) {
if (!is_inside_scene())
return;
if (get_scene()->is_editor_hint())
draw_style_box(get_stylebox("border"),Rect2(Point2(),get_size())) ;
}
}
void CreateDialog::set_base_type(const String& p_base) {
set_title(vformat("Create %s Type",p_base));
if (base==p_base)
return;
base=p_base;
if (is_inside_scene())
update_tree();
}
void VideoPlayer::play() {
ERR_FAIL_COND(!is_inside_scene());
if (stream.is_null())
return;
stream->play();
AudioServer::get_singleton()->stream_set_active(stream_rid,true);
AudioServer::get_singleton()->stream_set_volume_scale(stream_rid,volume);
set_process(true);
};
void CreateDialog::set_base_type(const String& p_base) {
set_title("Create "+p_base+" Type");
if (base==p_base)
return;
base=p_base;
if (is_inside_scene())
update_tree();
}
Vector3 Camera::project_ray_origin(const Point2& p_pos) const {
if (!is_inside_scene()) {
ERR_EXPLAIN("Camera is not inside scene.");
ERR_FAIL_COND_V(!is_inside_scene(),Vector3());
}
#if 0
Size2 viewport_size = viewport_ptr->get_visible_rect().size;
Vector2 cpos = p_pos;
#else
Size2 viewport_size = viewport_ptr->get_camera_rect_size();
Vector2 cpos = viewport_ptr->get_camera_coords(p_pos);
#endif
ERR_FAIL_COND_V( viewport_size.y == 0, Vector3() );
// float aspect = viewport_size.x / viewport_size.y;
if (mode == PROJECTION_PERSPECTIVE) {
return get_camera_transform().origin;
} else {
Vector2 pos = cpos / viewport_size;
float vsize,hsize;
if (keep_aspect==KEEP_WIDTH) {
vsize = size/viewport_size.get_aspect();
hsize = size;
} else {
hsize = size*viewport_size.get_aspect();
vsize = size;
}
Vector3 ray;
ray.x = pos.x * (hsize) - hsize/2;
ray.y = (1.0 - pos.y) * (vsize) - vsize/2;
ray.z = -near;
ray = get_camera_transform().xform(ray);
return ray;
};
};
void Viewport::unhandled_input(const InputEvent& p_event) {
ERR_FAIL_COND(!is_inside_scene());
get_scene()->_call_input_pause(unhandled_input_group,"_unhandled_input",p_event);
//call_group(GROUP_CALL_REVERSE|GROUP_CALL_REALTIME|GROUP_CALL_MULIILEVEL,"unhandled_input","_unhandled_input",ev);
if (!get_scene()->input_handled && p_event.type==InputEvent::KEY) {
get_scene()->_call_input_pause(unhandled_key_input_group,"_unhandled_key_input",p_event);
//call_group(GROUP_CALL_REVERSE|GROUP_CALL_REALTIME|GROUP_CALL_MULIILEVEL,"unhandled_key_input","_unhandled_key_input",ev);
}
}
void VideoPlayer::stop() {
if (!is_inside_scene())
return;
if (stream.is_null())
return;
AudioServer::get_singleton()->stream_set_active(stream_rid,false);
stream->stop();
set_process(false);
};
void Viewport::update_worlds() {
if (!is_inside_scene())
return;
Rect2 xformed_rect = (global_canvas_transform * canvas_transform).affine_inverse().xform(get_visible_rect());
find_world_2d()->_update_viewport(this,xformed_rect);
find_world_2d()->_update();
find_world()->_update(get_scene()->get_frame());
}
