/*************************************************************************/
/*  viewport.cpp                                                         */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2017 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 "viewport.h"
#include "os/os.h"
#include "scene/3d/spatial.h"
#include "os/input.h"
#include "servers/physics_2d_server.h"
//#include "scene/3d/camera.h"

#include "servers/spatial_sound_server.h"
#include "servers/spatial_sound_2d_server.h"
#include "scene/gui/control.h"
#include "scene/3d/camera.h"
#include "scene/3d/listener.h"
#include "scene/resources/mesh.h"
#include "scene/3d/spatial_indexer.h"
#include "scene/3d/collision_object.h"

#include "scene/2d/collision_object_2d.h"

#include "scene/gui/panel.h"
#include "scene/gui/label.h"
#include "scene/main/timer.h"
#include "scene/scene_string_names.h"

#include "globals.h"

void ViewportTexture::setup_local_to_scene() {

	if (vp) {
		vp->viewport_textures.erase(this);
	}

	vp=NULL;

	Node *local_scene = get_local_scene();
	if (!local_scene) {
		return;
	}

	Node *vpn = local_scene->get_node(path);
	ERR_EXPLAIN("ViewportTexture: Path to node is invalid");
	ERR_FAIL_COND(!vpn);

	vp = vpn->cast_to<Viewport>();

	ERR_EXPLAIN("ViewportTexture: Path to node does not point to a viewport");
	ERR_FAIL_COND(!vp);

	vp->viewport_textures.insert(this);
}

void ViewportTexture::set_viewport_path_in_scene(const NodePath& p_path) {

	if (path==p_path)
		return;

	path=p_path;

	if (get_local_scene()) {
		setup_local_to_scene();
	}

}

NodePath ViewportTexture::get_viewport_path_in_scene() const {

	return path;
}

int ViewportTexture::get_width() const {

	ERR_FAIL_COND_V(!vp,0);
	return vp->size.width;
}
int ViewportTexture::get_height() const{

	ERR_FAIL_COND_V(!vp,0);
	return vp->size.height;
}
Size2 ViewportTexture::get_size() const{

	ERR_FAIL_COND_V(!vp,Size2());
	return vp->size;
}
RID ViewportTexture::get_rid() const{

	ERR_FAIL_COND_V(!vp,RID());
	return vp->texture_rid;
}

bool ViewportTexture::has_alpha() const{

	return false;
}

void ViewportTexture::set_flags(uint32_t p_flags){

	if (!vp)
		return;

	vp->texture_flags=p_flags;
	VS::get_singleton()->texture_set_flags(vp->texture_rid,p_flags);

}

uint32_t ViewportTexture::get_flags() const{

	if (!vp)
		return 0;

	return vp->texture_flags;
}

void ViewportTexture::_bind_methods() {

	ClassDB::bind_method(_MD("set_viewport_path_in_scene","path"),&ViewportTexture::set_viewport_path_in_scene);
	ClassDB::bind_method(_MD("get_viewport_path_in_scene"),&ViewportTexture::get_viewport_path_in_scene);

	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"viewport_path"),_SCS("set_viewport_path_in_scene"),_SCS("get_viewport_path_in_scene"));

}

ViewportTexture::ViewportTexture(){

	vp=NULL;
	set_local_to_scene(true);

}

ViewportTexture::~ViewportTexture(){

	if (vp) {
		vp->viewport_textures.erase(this);
	}
}

/////////////////////////////////////

class TooltipPanel : public Panel {

	GDCLASS(TooltipPanel,Panel)
public:
	TooltipPanel() {};

};

class TooltipLabel : public Label {

	GDCLASS(TooltipLabel,Label)
public:
	TooltipLabel() {};

};


Viewport::GUI::GUI() {


	mouse_focus=NULL;
	mouse_focus_button=-1;
	key_focus=NULL;
	mouse_over=NULL;

	cancelled_input_ID=0;
	tooltip=NULL;
	tooltip_popup=NULL;
	tooltip_label=NULL;
	subwindow_order_dirty=false;
}


/////////////////////////////////////
void Viewport::_update_stretch_transform() {

	if (size_override_stretch && size_override) {

		//print_line("sive override size "+size_override_size);
		//print_line("rect size "+size);
		stretch_transform=Matrix32();
		Size2 scale = size/(size_override_size+size_override_margin*2);
		stretch_transform.scale(scale);
		stretch_transform.elements[2]=size_override_margin*scale;


	} else {


		stretch_transform=Matrix32();
	}

	_update_global_transform();

}

void Viewport::_update_rect() {

	if (!is_inside_tree())
		return;


	/*if (!render_target && parent_control) {

		Control *c = parent_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);
	last_vp_rect=rect;

	if (canvas_item.is_valid()) {
		VisualServer::get_singleton()->canvas_item_set_custom_rect(canvas_item,true,rect);
	}

	emit_signal("size_changed");
	texture->emit_changed();
*/

}

void Viewport::_parent_resized() {

	_update_rect();
}

void Viewport::_parent_draw() {

}

void Viewport::_parent_visibility_changed() {

/*
	if (parent_control) {

		Control *c = parent_control;
		VisualServer::get_singleton()->canvas_item_set_visible(canvas_item,c->is_visible());

		_update_listener();
		_update_listener_2d();
	}
*/

}


void Viewport::_vp_enter_tree() {

/*	if (parent_control) {

		Control *cparent=parent_control;
		RID parent_ci = cparent->get_canvas_item();
		ERR_FAIL_COND(!parent_ci.is_valid());
		canvas_item = VisualServer::get_singleton()->canvas_item_create();

		VisualServer::get_singleton()->canvas_item_set_parent(canvas_item,parent_ci);
		VisualServer::get_singleton()->canvas_item_set_visible(canvas_item,false);
//		VisualServer::get_singleton()->canvas_item_attach_viewport(canvas_item,viewport);
		parent_control->connect("resized",this,"_parent_resized");
		parent_control->connect("visibility_changed",this,"_parent_visibility_changed");
	} else if (!parent){

//		VisualServer::get_singleton()->viewport_attach_to_screen(viewport,0);

	}
*/

}

void Viewport::_vp_exit_tree() {

	/*
	if (parent_control) {

		parent_control->disconnect("resized",this,"_parent_resized");
	}

	if (parent_control) {

		parent_control->disconnect("visibility_changed",this,"_parent_visibility_changed");
	}

	if (canvas_item.is_valid()) {

		VisualServer::get_singleton()->free(canvas_item);
		canvas_item=RID();

	}

	if (!parent) {

		VisualServer::get_singleton()->viewport_detach(viewport);

	}
*/
}


void Viewport::update_worlds() {

	if (!is_inside_tree())
		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_tree()->get_frame());
}


void Viewport::_test_new_mouseover(ObjectID new_collider) {
#ifndef _3D_DISABLED
	if (new_collider!=physics_object_over) {

		if (physics_object_over) {
			Object *obj = ObjectDB::get_instance(physics_object_over);
			if (obj) {
				CollisionObject *co = obj->cast_to<CollisionObject>();
				if (co) {
					co->_mouse_exit();
				}
			}
		}

		if (new_collider) {
			Object *obj = ObjectDB::get_instance(new_collider);
			if (obj) {
				CollisionObject *co = obj->cast_to<CollisionObject>();
				if (co) {
					co->_mouse_enter();

				}
			}

		}

		physics_object_over=new_collider;

	}
#endif

}

void Viewport::_notification(int p_what) {


	switch( p_what ) {

		case NOTIFICATION_ENTER_TREE: {

			if (get_parent()) {
				parent = get_parent()->get_viewport();
				VisualServer::get_singleton()->viewport_set_parent_viewport(viewport,parent->get_viewport());
			} else {
				parent=NULL;
			}

			current_canvas=find_world_2d()->get_canvas();
			VisualServer::get_singleton()->viewport_set_scenario(viewport,find_world()->get_scenario());
			VisualServer::get_singleton()->viewport_attach_canvas(viewport,current_canvas);

			_update_listener();
			_update_listener_2d();
			_update_rect();

			find_world_2d()->_register_viewport(this,Rect2());

			add_to_group("_viewports");
			if (get_tree()->is_debugging_collisions_hint()) {
				//2D
				Physics2DServer::get_singleton()->space_set_debug_contacts(find_world_2d()->get_space(),get_tree()->get_collision_debug_contact_count());
				contact_2d_debug=VisualServer::get_singleton()->canvas_item_create();
				VisualServer::get_singleton()->canvas_item_set_parent(contact_2d_debug,find_world_2d()->get_canvas());
				//3D
				PhysicsServer::get_singleton()->space_set_debug_contacts(find_world()->get_space(),get_tree()->get_collision_debug_contact_count());
				contact_3d_debug_multimesh=VisualServer::get_singleton()->multimesh_create();
				VisualServer::get_singleton()->multimesh_allocate(contact_3d_debug_multimesh,get_tree()->get_collision_debug_contact_count(),VS::MULTIMESH_TRANSFORM_3D,VS::MULTIMESH_COLOR_8BIT);
				VisualServer::get_singleton()->multimesh_set_visible_instances(contact_3d_debug_multimesh,0);
				VisualServer::get_singleton()->multimesh_set_mesh(contact_3d_debug_multimesh,get_tree()->get_debug_contact_mesh()->get_rid());
				contact_3d_debug_instance=VisualServer::get_singleton()->instance_create();
				VisualServer::get_singleton()->instance_set_base(contact_3d_debug_instance,contact_3d_debug_multimesh);
				VisualServer::get_singleton()->instance_set_scenario(contact_3d_debug_instance,find_world()->get_scenario());
				VisualServer::get_singleton()->instance_geometry_set_flag(contact_3d_debug_instance,VS::INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS,true);

			}

			VS::get_singleton()->viewport_set_active(viewport,true);
		} break;
		case NOTIFICATION_READY: {
#ifndef _3D_DISABLED
			if (listeners.size() && !listener) {
				Listener *first=NULL;
				for(Set<Listener*>::Element *E=listeners.front();E;E=E->next()) {

					if (first==NULL || first->is_greater_than(E->get())) {
						first=E->get();
					}
				}

				if (first)
					first->make_current();
			}

			if (cameras.size() && !camera) {
				//there are cameras but no current camera, pick first in tree and make it current
				Camera *first=NULL;
				for(Set<Camera*>::Element *E=cameras.front();E;E=E->next()) {

					if (first==NULL || first->is_greater_than(E->get())) {
						first=E->get();
					}
				}

				if (first)
					first->make_current();
			}
#endif
		} break;
		case NOTIFICATION_EXIT_TREE: {


			_gui_cancel_tooltip();
			if (world_2d.is_valid())
				world_2d->_remove_viewport(this);

			//if (!render_target)
			//	_vp_exit_tree();

			VisualServer::get_singleton()->viewport_set_scenario(viewport,RID());
			SpatialSoundServer::get_singleton()->listener_set_space(internal_listener, RID());
			VisualServer::get_singleton()->viewport_remove_canvas(viewport,current_canvas);
			if (contact_2d_debug.is_valid()) {
				VisualServer::get_singleton()->free(contact_2d_debug);
				contact_2d_debug=RID();
			}

			if (contact_3d_debug_multimesh.is_valid()) {
				VisualServer::get_singleton()->free(contact_3d_debug_multimesh);
				VisualServer::get_singleton()->free(contact_3d_debug_instance);
				contact_3d_debug_instance=RID();
				contact_3d_debug_multimesh=RID();
			}

			remove_from_group("_viewports");


			VS::get_singleton()->viewport_set_active(viewport,false);


		} break;
		case NOTIFICATION_FIXED_PROCESS: {

			if (gui.tooltip_timer>=0) {
				gui.tooltip_timer-=get_fixed_process_delta_time();
				if (gui.tooltip_timer<0) {
					_gui_show_tooltip();
				}
			}

			if (get_tree()->is_debugging_collisions_hint() && contact_2d_debug.is_valid()) {

				VisualServer::get_singleton()->canvas_item_clear(contact_2d_debug);
				VisualServer::get_singleton()->canvas_item_set_draw_index(contact_2d_debug,0xFFFFF); //very high index

				Vector<Vector2> points = Physics2DServer::get_singleton()->space_get_contacts(find_world_2d()->get_space());
				int point_count = Physics2DServer::get_singleton()->space_get_contact_count(find_world_2d()->get_space());
				Color ccol = get_tree()->get_debug_collision_contact_color();


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

					VisualServer::get_singleton()->canvas_item_add_rect(contact_2d_debug,Rect2(points[i]-Vector2(2,2),Vector2(5,5)),ccol);
				}
			}

			if (get_tree()->is_debugging_collisions_hint() && contact_3d_debug_multimesh.is_valid()) {


				Vector<Vector3> points = PhysicsServer::get_singleton()->space_get_contacts(find_world()->get_space());
				int point_count = PhysicsServer::get_singleton()->space_get_contact_count(find_world()->get_space());


				VS::get_singleton()->multimesh_set_visible_instances(contact_3d_debug_multimesh,point_count);

			}



			if (physics_object_picking && (to_screen_rect==Rect2() || Input::get_singleton()->get_mouse_mode()!=Input::MOUSE_MODE_CAPTURED)) {

				Vector2 last_pos(1e20,1e20);
				CollisionObject *last_object;
				ObjectID last_id=0;
				PhysicsDirectSpaceState::RayResult result;
				Physics2DDirectSpaceState *ss2d=Physics2DServer::get_singleton()->space_get_direct_state(find_world_2d()->get_space());

				bool motion_tested=false;

				while(physics_picking_events.size()) {

					InputEvent ev = physics_picking_events.front()->get();
					physics_picking_events.pop_front();

					Vector2 pos;
					switch(ev.type) {
						case InputEvent::MOUSE_MOTION: {
							pos.x=ev.mouse_motion.x;
							pos.y=ev.mouse_motion.y;
							motion_tested=true;
							physics_last_mousepos=pos;
						} break;
						case InputEvent::MOUSE_BUTTON: {
							pos.x=ev.mouse_button.x;
							pos.y=ev.mouse_button.y;

						} break;
						case InputEvent::SCREEN_DRAG: {
							pos.x=ev.screen_drag.x;
							pos.y=ev.screen_drag.y;
						} break;
						case InputEvent::SCREEN_TOUCH: {
							pos.x=ev.screen_touch.x;
							pos.y=ev.screen_touch.y;
						} break;

					}

					if (ss2d) {
						//send to 2D


						uint64_t frame = get_tree()->get_frame();

						Vector2 point = get_canvas_transform().affine_inverse().xform(pos);
						Physics2DDirectSpaceState::ShapeResult res[64];
						int rc = ss2d->intersect_point(point,res,64,Set<RID>(),0xFFFFFFFF,0xFFFFFFFF,true);
						for(int i=0;i<rc;i++) {

							if (res[i].collider_id && res[i].collider) {
								CollisionObject2D *co=res[i].collider->cast_to<CollisionObject2D>();
								if (co) {

									Map<ObjectID,uint64_t>::Element *E=physics_2d_mouseover.find(res[i].collider_id);
									if (!E) {
										E=physics_2d_mouseover.insert(res[i].collider_id,frame);
										co->_mouse_enter();
									} else {
										E->get()=frame;
									}

									co->_input_event(this,ev,res[i].shape);
								}
							}
						}

						List<Map<ObjectID,uint64_t>::Element*> to_erase;

						for (Map<ObjectID,uint64_t>::Element*E=physics_2d_mouseover.front();E;E=E->next()) {
							if (E->get()!=frame) {
								Object *o=ObjectDB::get_instance(E->key());
								if (o) {

									CollisionObject2D *co=o->cast_to<CollisionObject2D>();
									if (co) {
										co->_mouse_exit();
									}
								}
								to_erase.push_back(E);
							}
						}

						while(to_erase.size()) {
							physics_2d_mouseover.erase(to_erase.front()->get());
							to_erase.pop_front();
						}

					}



#ifndef _3D_DISABLED
					bool captured=false;

					if (physics_object_capture!=0) {


						Object *obj = ObjectDB::get_instance(physics_object_capture);
						if (obj) {
							CollisionObject *co = obj->cast_to<CollisionObject>();
							if (co) {
								co->_input_event(camera,ev,Vector3(),Vector3(),0);
								captured=true;
								if (ev.type==InputEvent::MOUSE_BUTTON && ev.mouse_button.button_index==1 && !ev.mouse_button.pressed) {
									physics_object_capture=0;
								}

							} else {
								physics_object_capture=0;
							}
						} else {
							physics_object_capture=0;
						}
					}


					if (captured) {
						//none
					} else if (pos==last_pos) {

						if (last_id) {
							if (ObjectDB::get_instance(last_id)) {
								//good, exists
								last_object->_input_event(camera,ev,result.position,result.normal,result.shape);
								if (last_object->get_capture_input_on_drag() && ev.type==InputEvent::MOUSE_BUTTON && ev.mouse_button.button_index==1 && ev.mouse_button.pressed) {
									physics_object_capture=last_id;
								}


							}
						}
					} else {




						if (camera) {

							Vector3 from = camera->project_ray_origin(pos);
							Vector3 dir = camera->project_ray_normal(pos);

							PhysicsDirectSpaceState *space = PhysicsServer::get_singleton()->space_get_direct_state(find_world()->get_space());
							if (space) {

								bool col = space->intersect_ray(from,from+dir*10000,result,Set<RID>(),0xFFFFFFFF,0xFFFFFFFF,true);
								ObjectID new_collider=0;
								if (col) {

									if (result.collider) {

										CollisionObject *co = result.collider->cast_to<CollisionObject>();
										if (co) {

											co->_input_event(camera,ev,result.position,result.normal,result.shape);
											last_object=co;
											last_id=result.collider_id;
											new_collider=last_id;
											if (co->get_capture_input_on_drag() && ev.type==InputEvent::MOUSE_BUTTON && ev.mouse_button.button_index==1 && ev.mouse_button.pressed) {
												physics_object_capture=last_id;
											}

										}
									}
								}

								if (ev.type==InputEvent::MOUSE_MOTION) {
									_test_new_mouseover(new_collider);
								}
							}

							last_pos=pos;
						}
					}
				}

				if (!motion_tested && camera && physics_last_mousepos!=Vector2(1e20,1e20)) {

					//test anyway for mouseenter/exit because objects might move
					Vector3 from = camera->project_ray_origin(physics_last_mousepos);
					Vector3 dir = camera->project_ray_normal(physics_last_mousepos);

					PhysicsDirectSpaceState *space = PhysicsServer::get_singleton()->space_get_direct_state(find_world()->get_space());
					if (space) {

						bool col = space->intersect_ray(from,from+dir*10000,result,Set<RID>(),0xFFFFFFFF,0xFFFFFFFF,true);
						ObjectID new_collider=0;
						if (col) {
							if (result.collider) {
								CollisionObject *co = result.collider->cast_to<CollisionObject>();
								if (co) {
									new_collider=result.collider_id;

								}
							}
						}

						_test_new_mouseover(new_collider);

					}
#endif
				}

			}

		} break;
	}
}

RID Viewport::get_viewport() const {

	return viewport;
}

void Viewport::set_size(const Size2 &p_size) {

	if (size==p_size.floor())
		return;
	size=p_size.floor();
	VS::get_singleton()->viewport_set_size(viewport,size.width,size.height);

	_update_rect();
	_update_stretch_transform();

	emit_signal("size_changed");

}

Rect2 Viewport::get_visible_rect() const {


	Rect2 r;

	if (size==Size2()) {

		r=Rect2( Point2(), Size2( OS::get_singleton()->get_video_mode().width, OS::get_singleton()->get_video_mode().height ) );
	} else {

		r=Rect2( Point2() , size );
	}

	if (size_override) {
		r.size=size_override_size;
	}


	return r;
}

Size2 Viewport::get_size() const {

	return size;
}


void Viewport::_update_listener() {

	if (is_inside_tree() && audio_listener && (camera || listener) && (!get_parent() || (get_parent()->cast_to<Control>() && get_parent()->cast_to<Control>()->is_visible())))  {
		SpatialSoundServer::get_singleton()->listener_set_space(internal_listener, find_world()->get_sound_space());
	} else {
		SpatialSoundServer::get_singleton()->listener_set_space(internal_listener, RID());
	}


}

void Viewport::_update_listener_2d() {

	if (is_inside_tree() && audio_listener && (!get_parent() || (get_parent()->cast_to<Control>() && get_parent()->cast_to<Control>()->is_visible())))
		SpatialSound2DServer::get_singleton()->listener_set_space(internal_listener_2d, find_world_2d()->get_sound_space());
	else
		SpatialSound2DServer::get_singleton()->listener_set_space(internal_listener_2d, RID());

}


void Viewport::set_as_audio_listener(bool p_enable) {

	if (p_enable==audio_listener)
		return;

	audio_listener=p_enable;
	_update_listener();

}

bool Viewport::is_audio_listener() const {

	return  audio_listener;
}

void Viewport::set_as_audio_listener_2d(bool p_enable) {

	if (p_enable==audio_listener_2d)
		return;

	audio_listener_2d=p_enable;

	_update_listener_2d();


}

bool Viewport::is_audio_listener_2d() const {

	return  audio_listener_2d;
}

void Viewport::set_canvas_transform(const Matrix32& p_transform) {

	canvas_transform=p_transform;
	VisualServer::get_singleton()->viewport_set_canvas_transform(viewport,find_world_2d()->get_canvas(),canvas_transform);

	Matrix32 xform = (global_canvas_transform * canvas_transform).affine_inverse();
	Size2 ss = get_visible_rect().size;
	SpatialSound2DServer::get_singleton()->listener_set_transform(internal_listener_2d, Matrix32(0, xform.xform(ss*0.5)));
	Vector2 ss2 = ss*xform.get_scale();
	float panrange = MAX(ss2.x,ss2.y);

	SpatialSound2DServer::get_singleton()->listener_set_param(internal_listener_2d, SpatialSound2DServer::LISTENER_PARAM_PAN_RANGE, panrange);


}

Matrix32 Viewport::get_canvas_transform() const{

	return canvas_transform;
}



void Viewport::_update_global_transform() {


	Matrix32 sxform = stretch_transform * global_canvas_transform;

	VisualServer::get_singleton()->viewport_set_global_canvas_transform(viewport,sxform);

	Matrix32 xform = (sxform * canvas_transform).affine_inverse();
	Size2 ss = get_visible_rect().size;
	SpatialSound2DServer::get_singleton()->listener_set_transform(internal_listener_2d, Matrix32(0, xform.xform(ss*0.5)));
	Vector2 ss2 = ss*xform.get_scale();
	float panrange = MAX(ss2.x,ss2.y);

	SpatialSound2DServer::get_singleton()->listener_set_param(internal_listener_2d, SpatialSound2DServer::LISTENER_PARAM_PAN_RANGE, panrange);

}


void Viewport::set_global_canvas_transform(const Matrix32& p_transform) {

	global_canvas_transform=p_transform;

	_update_global_transform();


}

Matrix32 Viewport::get_global_canvas_transform() const{

	return global_canvas_transform;
}

void Viewport::_listener_transform_changed_notify() {

#ifndef _3D_DISABLED
	if (listener)
		SpatialSoundServer::get_singleton()->listener_set_transform(internal_listener, listener->get_listener_transform());
#endif
}

void Viewport::_listener_set(Listener* p_listener) {

#ifndef _3D_DISABLED

	if (listener == p_listener)
		return;

	listener = p_listener;

	_update_listener();
	_listener_transform_changed_notify();
#endif
}

bool Viewport::_listener_add(Listener* p_listener) {

	listeners.insert(p_listener);
	return listeners.size() == 1;
}

void Viewport::_listener_remove(Listener* p_listener) {

	listeners.erase(p_listener);
	if (listener == p_listener) {
		listener = NULL;
	}
}

#ifndef _3D_DISABLED
void Viewport::_listener_make_next_current(Listener* p_exclude) {

	if (listeners.size() > 0) {
		for (Set<Listener*>::Element *E = listeners.front(); E; E = E->next()) {

			if (p_exclude == E->get())
				continue;
			if (!E->get()->is_inside_tree())
				continue;
			if (listener != NULL)
				return;

			E->get()->make_current();

		}
	}
	else {
		// Attempt to reset listener to the camera position
		if (camera != NULL) {
			_update_listener();
			_camera_transform_changed_notify();
		}
	}
}
#endif

void Viewport::_camera_transform_changed_notify() {

#ifndef _3D_DISABLED
	// If there is an active listener in the scene, it takes priority over the camera
	if (camera && !listener)
		SpatialSoundServer::get_singleton()->listener_set_transform(internal_listener, camera->get_camera_transform());
#endif
}

void Viewport::_camera_set(Camera* p_camera) {

#ifndef _3D_DISABLED

	if (camera==p_camera)
		return;

	if (camera && find_world().is_valid()) {
		camera->notification(Camera::NOTIFICATION_LOST_CURRENT);
	}
	camera=p_camera;
	if (camera)
		VisualServer::get_singleton()->viewport_attach_camera(viewport,camera->get_camera());
	else
		VisualServer::get_singleton()->viewport_attach_camera(viewport,RID());

	if (camera && find_world().is_valid()) {
		camera->notification(Camera::NOTIFICATION_BECAME_CURRENT);
	}

	_update_listener();
	_camera_transform_changed_notify();
#endif
}

bool Viewport::_camera_add(Camera* p_camera) {

	cameras.insert(p_camera);
	return cameras.size()==1;
}

void Viewport::_camera_remove(Camera* p_camera) {

	cameras.erase(p_camera);
	if (camera==p_camera) {
		camera=NULL;
	}
}

#ifndef _3D_DISABLED
void Viewport::_camera_make_next_current(Camera* p_exclude) {

	for(Set<Camera*>::Element *E=cameras.front();E;E=E->next()) {

		if (p_exclude==E->get())
			continue;
		if (!E->get()->is_inside_tree())
			continue;
		if (camera!=NULL)
			return;

		E->get()->make_current();

	}
}
#endif

void Viewport::set_transparent_background(bool p_enable) {

	transparent_bg=p_enable;
	VS::get_singleton()->viewport_set_transparent_background(viewport,p_enable);

}

bool Viewport::has_transparent_background() const {

	return transparent_bg;
}

void Viewport::set_world_2d(const Ref<World2D>& p_world_2d) {
	if (world_2d==p_world_2d)
		return;

	if (parent && parent->find_world_2d()==p_world_2d) {
		WARN_PRINT("Unable to use parent world as world_2d");
		return;
	}

	if (is_inside_tree()) {
		find_world_2d()->_remove_viewport(this);
		VisualServer::get_singleton()->viewport_remove_canvas(viewport,current_canvas);
	}

	if (p_world_2d.is_valid())
		world_2d=p_world_2d;
	else {
		WARN_PRINT("Invalid world");
		world_2d=Ref<World2D>( memnew( World2D ));
	}

	_update_listener_2d();

	if (is_inside_tree()) {
		current_canvas=find_world_2d()->get_canvas();
		VisualServer::get_singleton()->viewport_attach_canvas(viewport,current_canvas);
		find_world_2d()->_register_viewport(this,Rect2());
	}
}

Ref<World2D> Viewport::find_world_2d() const{

	if (world_2d.is_valid())
		return world_2d;
	else if (parent)
		return parent->find_world_2d();
	else
		return Ref<World2D>();
}

void Viewport::_propagate_enter_world(Node *p_node) {


	if (p_node!=this) {

		if (!p_node->is_inside_tree()) //may not have entered scene yet
			return;

		Spatial *s = p_node->cast_to<Spatial>();
		if (s) {

			s->notification(Spatial::NOTIFICATION_ENTER_WORLD);
		} else {
			Viewport *v = p_node->cast_to<Viewport>();
			if (v) {

				if (v->world.is_valid())
					return;
			}
		}
	}


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

		_propagate_enter_world(p_node->get_child(i));
	}
}

void Viewport::_propagate_viewport_notification(Node* p_node,int p_what) {

	p_node->notification(p_what);
	for(int i=0;i<p_node->get_child_count();i++) {
		Node *c = p_node->get_child(i);
		if (c->cast_to<Viewport>())
			continue;
		_propagate_viewport_notification(c,p_what);
	}
}

void Viewport::_propagate_exit_world(Node *p_node) {

	if (p_node!=this) {

		if (!p_node->is_inside_tree()) //may have exited scene already
			return;

		Spatial *s = p_node->cast_to<Spatial>();
		if (s) {

			s->notification(Spatial::NOTIFICATION_EXIT_WORLD, true);
		} else {
			Viewport *v = p_node->cast_to<Viewport>();
			if (v) {

				if (v->world.is_valid())
					return;
			}
		}
	}


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

		_propagate_exit_world(p_node->get_child(i));
	}

}


void Viewport::set_world(const Ref<World>& p_world) {

	if (world==p_world)
		return;

	if (is_inside_tree())
		_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_tree())
		_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_tree()) {
		VisualServer::get_singleton()->viewport_set_scenario(viewport,find_world()->get_scenario());
	}

	_update_listener();

}

Ref<World> Viewport::get_world() const{

	return world;
}

Ref<World2D> Viewport::get_world_2d() const{

	return world_2d;
}

Ref<World> Viewport::find_world() const{

	if (own_world.is_valid())
		return own_world;
	else if (world.is_valid())
		return world;
	else if (parent)
		return parent->find_world();
	else
		return Ref<World>();
}

Listener* Viewport::get_listener() const {

	return listener;
}

Camera* Viewport::get_camera() const {

	return camera;
}


Matrix32 Viewport::get_final_transform() const {

	return stretch_transform * global_canvas_transform;
}

void Viewport::set_size_override(bool p_enable, const Size2& p_size, const Vector2 &p_margin) {

	if (size_override==p_enable && p_size==size_override_size)
		return;

	size_override=p_enable;
	if (p_size.x>=0 || p_size.y>=0) {
		size_override_size=p_size;
	}
	size_override_margin=p_margin;
	_update_rect();
	_update_stretch_transform();


}

Size2 Viewport::get_size_override() const {

	return size_override_size;
}
bool Viewport::is_size_override_enabled() const {

	return size_override;
}
void Viewport::set_size_override_stretch(bool p_enable) {

	if (p_enable==size_override_stretch)
		return;

	size_override_stretch=p_enable;
	if (size_override) {
		_update_rect();
	}


	_update_stretch_transform();
}


bool Viewport::is_size_override_stretch_enabled() const {

	return size_override_stretch;
}
#if 0
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_tree()) {

		if (p_enable)
			_vp_exit_tree();
		else
			_vp_enter_tree();
	}

	if (p_enable) {

		texture_rid = VS::get_singleton()->viewport_get_texture(viewport);
	} else {

		texture_rid=RID();
	}

	texture->set_flags(texture->flags);
	texture->emit_changed();

	update_configuration_warning();
	*/
}

bool Viewport::is_set_as_render_target() const{

	return render_target;

}
#endif
void Viewport::set_update_mode(UpdateMode p_mode){

	update_mode=p_mode;
	VS::get_singleton()->viewport_set_update_mode(viewport,VS::ViewportUpdateMode(p_mode));

}
Viewport::UpdateMode Viewport::get_update_mode() const{

	return update_mode;
}
//RID get_texture() const;

void Viewport::queue_screen_capture(){

	//VS::get_singleton()->viewport_queue_screen_capture(viewport);
}
Image Viewport::get_screen_capture() const {

//	return VS::get_singleton()->viewport_get_screen_capture(viewport);
	return Image();
}

Ref<ViewportTexture> Viewport::get_texture() const {

	return default_texture;
}

void Viewport::set_vflip(bool p_enable) {

	vflip=p_enable;
	VisualServer::get_singleton()->viewport_set_vflip(viewport,p_enable);
}

bool Viewport::get_vflip() const{

	return vflip;
}

void Viewport::set_clear_on_new_frame(bool p_enable) {

	clear_on_new_frame=p_enable;
	//VisualServer::get_singleton()->viewport_set_clear_on_new_frame(viewport,p_enable);
}

bool Viewport::get_clear_on_new_frame() const{

	return clear_on_new_frame;
}

void Viewport::set_shadow_atlas_size(int p_size) {

	if (shadow_atlas_size==p_size)
		return;

	shadow_atlas_size=p_size;
	VS::get_singleton()->viewport_set_shadow_atlas_size(viewport,p_size);
}

int Viewport::get_shadow_atlas_size() const{

	return shadow_atlas_size;
}

void Viewport::set_shadow_atlas_quadrant_subdiv(int p_quadrant,ShadowAtlasQuadrantSubdiv p_subdiv){


	ERR_FAIL_INDEX(p_quadrant,4);
	ERR_FAIL_INDEX(p_subdiv,SHADOW_ATLAS_QUADRANT_SUBDIV_MAX);

	if (shadow_atlas_quadrant_subdiv[p_quadrant]==p_subdiv)
		return;

	shadow_atlas_quadrant_subdiv[p_quadrant]=p_subdiv;
	static const int subdiv[SHADOW_ATLAS_QUADRANT_SUBDIV_MAX]={0,1,4,16,64,256,1024};

	VS::get_singleton()->viewport_set_shadow_atlas_quadrant_subdivision(viewport,p_quadrant,subdiv[p_subdiv]);

}
Viewport::ShadowAtlasQuadrantSubdiv Viewport::get_shadow_atlas_quadrant_subdiv(int p_quadrant) const{

	ERR_FAIL_INDEX_V(p_quadrant,4,SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED);
	return shadow_atlas_quadrant_subdiv[p_quadrant];
}


void Viewport::clear() {

	//clear=true;
//	VisualServer::get_singleton()->viewport_clear(viewport);
}


Matrix32 Viewport::_get_input_pre_xform() const {

	Matrix32 pre_xf;


	if (to_screen_rect!=Rect2()) {

		pre_xf.elements[2]=-to_screen_rect.pos;
		pre_xf.scale(size/to_screen_rect.size);
	}

	return pre_xf;
}

Vector2 Viewport::_get_window_offset() const {

//	if (parent_control) {
//		return (parent_control->get_viewport()->get_final_transform() * parent_control->get_global_transform_with_canvas()).get_origin();
//	}

	return Vector2();
}

void Viewport::_make_input_local(InputEvent& ev) {


	switch(ev.type) {

		case InputEvent::MOUSE_BUTTON: {

			Vector2 vp_ofs = _get_window_offset();

			Matrix32 ai = get_final_transform().affine_inverse() * _get_input_pre_xform();
			Vector2 g = ai.xform(Vector2(ev.mouse_button.global_x,ev.mouse_button.global_y));
			Vector2 l = ai.xform(Vector2(ev.mouse_button.x,ev.mouse_button.y)-vp_ofs);


			ev.mouse_button.x=l.x;
			ev.mouse_button.y=l.y;
			ev.mouse_button.global_x=g.x;
			ev.mouse_button.global_y=g.y;

		} break;
		case InputEvent::MOUSE_MOTION: {

			Vector2 vp_ofs = _get_window_offset();

			Matrix32 ai = get_final_transform().affine_inverse() * _get_input_pre_xform();
			Vector2 g = ai.xform(Vector2(ev.mouse_motion.global_x,ev.mouse_motion.global_y));
			Vector2 l = ai.xform(Vector2(ev.mouse_motion.x,ev.mouse_motion.y)-vp_ofs);
			Vector2 r = ai.basis_xform(Vector2(ev.mouse_motion.relative_x,ev.mouse_motion.relative_y));
			Vector2 s = ai.basis_xform(Vector2(ev.mouse_motion.speed_x,ev.mouse_motion.speed_y));


			ev.mouse_motion.x=l.x;
			ev.mouse_motion.y=l.y;
			ev.mouse_motion.global_x=g.x;
			ev.mouse_motion.global_y=g.y;
			ev.mouse_motion.relative_x=r.x;
			ev.mouse_motion.relative_y=r.y;
			ev.mouse_motion.speed_x=s.x;
			ev.mouse_motion.speed_y=s.y;

		} break;
		case InputEvent::SCREEN_TOUCH: {

			Vector2 vp_ofs = _get_window_offset();

			Matrix32 ai = get_final_transform().affine_inverse() * _get_input_pre_xform();
			Vector2 t = ai.xform(Vector2(ev.screen_touch.x,ev.screen_touch.y)-vp_ofs);


			ev.screen_touch.x=t.x;
			ev.screen_touch.y=t.y;

		} break;
		case InputEvent::SCREEN_DRAG: {

			Vector2 vp_ofs = _get_window_offset();

			Matrix32 ai = get_final_transform().affine_inverse() * _get_input_pre_xform();
			Vector2 t = ai.xform(Vector2(ev.screen_drag.x,ev.screen_drag.y)-vp_ofs);
			Vector2 r = ai.basis_xform(Vector2(ev.screen_drag.relative_x,ev.screen_drag.relative_y));
			Vector2 s = ai.basis_xform(Vector2(ev.screen_drag.speed_x,ev.screen_drag.speed_y));
			ev.screen_drag.x=t.x;
			ev.screen_drag.y=t.y;
			ev.screen_drag.relative_x=r.x;
			ev.screen_drag.relative_y=r.y;
			ev.screen_drag.speed_x=s.x;
			ev.screen_drag.speed_y=s.y;
		} break;
	}


}

void Viewport::_vp_input_text(const String& p_text) {

	if (gui.key_focus) {
		gui.key_focus->call("set_text",p_text);
	}
}

void Viewport::_vp_input(const InputEvent& p_ev) {

	if (disable_input)
		return;

#ifdef TOOLS_ENABLED
	if (get_tree()->is_editor_hint() && get_tree()->get_edited_scene_root()->is_a_parent_of(this)) {
		return;
	}
#endif


	if (to_screen_rect==Rect2())
		return; //if render target, can't get input events

	//this one handles system input, p_ev are in system coordinates
	//they are converted to viewport coordinates


	InputEvent ev = p_ev;
	_make_input_local(ev);
	input(ev);

}

void Viewport::_vp_unhandled_input(const InputEvent& p_ev) {

	if (disable_input)
		return;
#ifdef TOOLS_ENABLED
	if (get_tree()->is_editor_hint() && get_tree()->get_edited_scene_root()->is_a_parent_of(this)) {
		return;
	}
#endif

//	if (parent_control && !parent_control->is_visible())
//		return;

	if (to_screen_rect==Rect2())
		return; //if render target, can't get input events

	//this one handles system input, p_ev are in system coordinates
	//they are converted to viewport coordinates

	InputEvent ev = p_ev;
	_make_input_local(ev);
	unhandled_input(ev);

}

Vector2 Viewport::get_mouse_pos() const {

	return (get_final_transform().affine_inverse() * _get_input_pre_xform()).xform(Input::get_singleton()->get_mouse_pos() - _get_window_offset());
}

void Viewport::warp_mouse(const Vector2& p_pos) {

	Vector2 gpos = (get_final_transform().affine_inverse() * _get_input_pre_xform()).affine_inverse().xform(p_pos);
	Input::get_singleton()->warp_mouse_pos(gpos);
}



void Viewport::_gui_sort_subwindows() {

	if (!gui.subwindow_order_dirty)
		return;


	gui.modal_stack.sort_custom<Control::CComparator>();
	gui.subwindows.sort_custom<Control::CComparator>();

	gui.subwindow_order_dirty=false;
}

void Viewport::_gui_sort_modal_stack() {

	gui.modal_stack.sort_custom<Control::CComparator>();
}


void Viewport::_gui_sort_roots() {

	if (!gui.roots_order_dirty)
		return;

	gui.roots.sort_custom<Control::CComparator>();

	gui.roots_order_dirty=false;
}


void Viewport::_gui_cancel_tooltip() {

	gui.tooltip=NULL;
	gui.tooltip_timer=-1;
	if (gui.tooltip_popup) {
		gui.tooltip_popup->queue_delete();
		gui.tooltip_popup=NULL;
	}

}

void Viewport::_gui_show_tooltip() {

	if (!gui.tooltip) {
		return;
	}

	String tooltip = gui.tooltip->get_tooltip( gui.tooltip->get_global_transform().xform_inv(gui.tooltip_pos) );
	if (tooltip.length()==0)
		return; // bye

	if (gui.tooltip_popup) {
		memdelete(gui.tooltip_popup);
		gui.tooltip_popup=NULL;
	}

	Control *rp = gui.tooltip->get_root_parent_control();
	if (!rp)
		return;


	gui.tooltip_popup = memnew( TooltipPanel );

	rp->add_child(gui.tooltip_popup);
	gui.tooltip_popup->force_parent_owned();
	gui.tooltip_label = memnew( TooltipLabel );
	gui.tooltip_popup->add_child(gui.tooltip_label);
	gui.tooltip_popup->set_as_toplevel(true);
	gui.tooltip_popup->hide();

	Ref<StyleBox> ttp = gui.tooltip_label->get_stylebox("panel","TooltipPanel");

	gui.tooltip_label->set_anchor_and_margin(MARGIN_LEFT,Control::ANCHOR_BEGIN,ttp->get_margin(MARGIN_LEFT));
	gui.tooltip_label->set_anchor_and_margin(MARGIN_TOP,Control::ANCHOR_BEGIN,ttp->get_margin(MARGIN_TOP));
	gui.tooltip_label->set_anchor_and_margin(MARGIN_RIGHT,Control::ANCHOR_END,ttp->get_margin(MARGIN_RIGHT));
	gui.tooltip_label->set_anchor_and_margin(MARGIN_BOTTOM,Control::ANCHOR_END,ttp->get_margin(MARGIN_BOTTOM));
	gui.tooltip_label->set_text(tooltip);
	Rect2 r(gui.tooltip_pos+Point2(10,10),gui.tooltip_label->get_combined_minimum_size()+ttp->get_minimum_size());
	Rect2 vr = gui.tooltip_label->get_viewport_rect();
	if (r.size.x+r.pos.x>vr.size.x)
		r.pos.x=vr.size.x-r.size.x;
	else if (r.pos.x<0)
		r.pos.x=0;

	if (r.size.y+r.pos.y>vr.size.y)
		r.pos.y=vr.size.y-r.size.y;
	else if (r.pos.y<0)
		r.pos.y=0;

	gui.tooltip_popup->set_global_pos(r.pos);
	gui.tooltip_popup->set_size(r.size);

	gui.tooltip_popup->raise();
	gui.tooltip_popup->show();
}


void Viewport::_gui_call_input(Control *p_control,const InputEvent& p_input) {

//	_block();


	InputEvent ev = p_input;

	//mouse wheel events can't be stopped
	bool cant_stop_me_now = (ev.type==InputEvent::MOUSE_BUTTON &&
				 (ev.mouse_button.button_index==BUTTON_WHEEL_DOWN ||
				  ev.mouse_button.button_index==BUTTON_WHEEL_UP ||
				  ev.mouse_button.button_index==BUTTON_WHEEL_LEFT ||
				  ev.mouse_button.button_index==BUTTON_WHEEL_RIGHT ) );

	CanvasItem *ci=p_control;
	while(ci) {

		Control *control = ci->cast_to<Control>();
		if (control) {
			control->call_multilevel(SceneStringNames::get_singleton()->_gui_input,ev);
			if (gui.key_event_accepted)
				break;
			if (!control->is_inside_tree())
				break;
			control->emit_signal(SceneStringNames::get_singleton()->gui_input,ev);
			if (!control->is_inside_tree() || control->is_set_as_toplevel())
				break;
			if (gui.key_event_accepted)
				break;
			if (!cant_stop_me_now && control->data.mouse_filter==Control::MOUSE_FILTER_STOP && (ev.type==InputEvent::MOUSE_BUTTON || ev.type==InputEvent::MOUSE_MOTION))
				break;
		}

		if (ci->is_set_as_toplevel())
			break;

		ev=ev.xform_by(ci->get_transform()); //transform event upwards
		ci=ci->get_parent_item();
	}

	//_unblock();

}

Control* Viewport::_gui_find_control(const Point2& p_global)  {

	_gui_sort_subwindows();

	for (List<Control*>::Element *E=gui.subwindows.back();E;E=E->prev()) {

		Control *sw = E->get();
		if (!sw->is_visible())
			continue;

		Matrix32 xform;
		CanvasItem *pci = sw->get_parent_item();
		if (pci)
			xform=pci->get_global_transform_with_canvas();
		else
			xform=sw->get_canvas_transform();

		Control *ret = _gui_find_control_at_pos(sw,p_global,xform,gui.focus_inv_xform);
		if (ret)
			return ret;
	}

	_gui_sort_roots();

	for (List<Control*>::Element *E=gui.roots.back();E;E=E->prev()) {

		Control *sw = E->get();
		if (!sw->is_visible())
			continue;

		Matrix32 xform;
		CanvasItem *pci = sw->get_parent_item();
		if (pci)
			xform=pci->get_global_transform_with_canvas();
		else
			xform=sw->get_canvas_transform();


		Control *ret = _gui_find_control_at_pos(sw,p_global,xform,gui.focus_inv_xform);
		if (ret)
			return ret;
	}

	return NULL;

}


Control* Viewport::_gui_find_control_at_pos(CanvasItem* p_node,const Point2& p_global,const Matrix32& p_xform,Matrix32& r_inv_xform)  {

	if (p_node->cast_to<Viewport>())
		return NULL;

	Control *c=p_node->cast_to<Control>();

	if (c) {
	//	print_line("at "+String(c->get_path())+" POS "+c->get_pos()+" bt "+p_xform);
	}

	//subwindows first!!

	if (p_node->is_hidden()) {
		//return _find_next_visible_control_at_pos(p_node,p_global,r_inv_xform);
		return NULL; //canvas item hidden, discard
	}

	Matrix32 matrix = p_xform * p_node->get_transform();
	// matrix.basis_determinant() == 0.0f implies that node does not exist on scene
	if(matrix.basis_determinant() == 0.0f)
		return NULL;

	if (!c || !c->clips_input() || c->has_point(matrix.affine_inverse().xform(p_global))) {

		for(int i=p_node->get_child_count()-1;i>=0;i--) {

			if (p_node==gui.tooltip_popup)
				continue;

			CanvasItem *ci = p_node->get_child(i)->cast_to<CanvasItem>();
			if (!ci || ci->is_set_as_toplevel())
				continue;

			Control *ret=_gui_find_control_at_pos(ci,p_global,matrix,r_inv_xform);;
			if (ret)
				return ret;
		}
	}

	if (!c)
		return NULL;

	matrix.affine_invert();

	//conditions for considering this as a valid control for return
	if (c->data.mouse_filter!=Control::MOUSE_FILTER_IGNORE && c->has_point(matrix.xform(p_global)) && (!gui.drag_preview || (c!=gui.drag_preview && !gui.drag_preview->is_a_parent_of(c)))) {
		r_inv_xform=matrix;
		return c;
	} else
		return NULL;
}

void Viewport::_gui_input_event(InputEvent p_event) {



	if (p_event.ID==gui.cancelled_input_ID) {
		return;
	}
	//?
//	if (!is_visible()) {
//		return; //simple and plain
//	}


	switch(p_event.type) {

		case InputEvent::MOUSE_BUTTON: {


			gui.key_event_accepted=false;

			Point2 mpos=Point2(p_event.mouse_button.x,p_event.mouse_button.y);
			if (p_event.mouse_button.pressed) {



				Size2 pos = mpos;
				if (gui.mouse_focus && p_event.mouse_button.button_index!=gui.mouse_focus_button) {

					//do not steal mouse focus and stuff

				} else {


					_gui_sort_modal_stack();
					while (!gui.modal_stack.empty()) {

						Control *top = gui.modal_stack.back()->get();
						Vector2 pos = top->get_global_transform_with_canvas().affine_inverse().xform(mpos);
						if (!top->has_point(pos)) {

							if (top->data.modal_exclusive || top->data.modal_frame==OS::get_singleton()->get_frames_drawn()) {
								//cancel event, sorry, modal exclusive EATS UP ALL
								//alternative, you can't pop out a window the same frame it was made modal (fixes many issues)
								get_tree()->set_input_as_handled();
								return; // no one gets the event if exclusive NO ONE
							}

							top->notification(Control::NOTIFICATION_MODAL_CLOSE);
							top->_modal_stack_remove();
							top->hide();
						} else {
							break;
						}
					}



					//Matrix32 parent_xform;

					//if (data.parent_canvas_item)
					//	parent_xform=data.parent_canvas_item->get_global_transform();



					gui.mouse_focus = _gui_find_control(pos);
					//print_line("has mf "+itos(gui.mouse_focus!=NULL));
					gui.mouse_focus_button=p_event.mouse_button.button_index;

					if (!gui.mouse_focus) {
						break;
					}

					if (p_event.mouse_button.button_index==BUTTON_LEFT) {
						gui.drag_accum=Vector2();
						gui.drag_attempted=false;
					}


				}


				p_event.mouse_button.global_x = pos.x;
				p_event.mouse_button.global_y = pos.y;

				pos = gui.focus_inv_xform.xform(pos);
				p_event.mouse_button.x = pos.x;
				p_event.mouse_button.y = pos.y;

#ifdef DEBUG_ENABLED
				if (ScriptDebugger::get_singleton()) {

					Array arr;
					arr.push_back(gui.mouse_focus->get_path());
					arr.push_back(gui.mouse_focus->get_class());
					ScriptDebugger::get_singleton()->send_message("click_ctrl",arr);
				}

				/*if (bool(GLOBAL_DEF("debug/print_clicked_control",false))) {

						print_line(String(gui.mouse_focus->get_path())+" - "+pos);
					}*/
#endif

				if (gui.mouse_focus->get_focus_mode()!=Control::FOCUS_NONE && gui.mouse_focus!=gui.key_focus && p_event.mouse_button.button_index==BUTTON_LEFT) {
					// also get keyboard focus
					gui.mouse_focus->grab_focus();
				}


				if (gui.mouse_focus->can_process()) {
					_gui_call_input(gui.mouse_focus,p_event);
				}

				get_tree()->call_group(SceneTree::GROUP_CALL_REALTIME,"windows","_cancel_input_ID",p_event.ID);
				get_tree()->set_input_as_handled();


				if (gui.drag_data.get_type()!=Variant::NIL && p_event.mouse_button.button_index==BUTTON_LEFT) {

					//alternate drop use (when using force_drag(), as proposed by #5342
					if (gui.mouse_focus && gui.mouse_focus->can_drop_data(pos,gui.drag_data)) {
						gui.mouse_focus->drop_data(pos,gui.drag_data);
					}

					gui.drag_data=Variant();

					if (gui.drag_preview) {
						memdelete( gui.drag_preview );
						gui.drag_preview=NULL;
					}
					_propagate_viewport_notification(this,NOTIFICATION_DRAG_END);
					//change mouse accordingly
				}



				_gui_cancel_tooltip();
				//gui.tooltip_popup->hide();

			} else {



				if (gui.drag_data.get_type()!=Variant::NIL && p_event.mouse_button.button_index==BUTTON_LEFT) {

					if (gui.mouse_over) {
						Size2 pos = mpos;
						pos = gui.focus_inv_xform.xform(pos);
						if (gui.mouse_over->can_drop_data(pos,gui.drag_data)) {
							gui.mouse_over->drop_data(pos,gui.drag_data);
						}
					}

					if (gui.drag_preview && p_event.mouse_button.button_index==BUTTON_LEFT) {
						memdelete( gui.drag_preview );
						gui.drag_preview=NULL;
					}

					gui.drag_data=Variant();
					_propagate_viewport_notification(this,NOTIFICATION_DRAG_END);
					//change mouse accordingly
				}

				if (!gui.mouse_focus) {
					//release event is only sent if a mouse focus (previously pressed button) exists
					break;
				}

				Size2 pos = mpos;
				p_event.mouse_button.global_x = pos.x;
				p_event.mouse_button.global_y = pos.y;
				pos = gui.focus_inv_xform.xform(pos);
				p_event.mouse_button.x = pos.x;
				p_event.mouse_button.y = pos.y;

				if (gui.mouse_focus->can_process()) {
					_gui_call_input(gui.mouse_focus,p_event);
				}

				if (p_event.mouse_button.button_index==gui.mouse_focus_button) {
					gui.mouse_focus=NULL;
					gui.mouse_focus_button=-1;
				}

				/*if (gui.drag_data.get_type()!=Variant::NIL && p_event.mouse_button.button_index==BUTTON_LEFT) {
					_propagate_viewport_notification(this,NOTIFICATION_DRAG_END);
					gui.drag_data=Variant(); //always clear
				}*/


				get_tree()->call_group(SceneTree::GROUP_CALL_REALTIME,"windows","_cancel_input_ID",p_event.ID);
				get_tree()->set_input_as_handled();

			}
		} break;
		case InputEvent::MOUSE_MOTION: {

			gui.key_event_accepted=false;
			Point2 mpos=Point2(p_event.mouse_motion.x,p_event.mouse_motion.y);

			gui.last_mouse_pos=mpos;

			Control *over = NULL;


			// D&D
			if (!gui.drag_attempted && gui.mouse_focus && p_event.mouse_motion.button_mask&BUTTON_MASK_LEFT) {

				gui.drag_accum+=Point2(p_event.mouse_motion.relative_x,p_event.mouse_motion.relative_y);;
				float len = gui.drag_accum.length();
				if (len>10) {
					gui.drag_data=gui.mouse_focus->get_drag_data(gui.focus_inv_xform.xform(mpos)-gui.drag_accum);
					if (gui.drag_data.get_type()!=Variant::NIL) {

						gui.mouse_focus=NULL;
					}
					gui.drag_attempted=true;
					if (gui.drag_data.get_type()!=Variant::NIL) {

						_propagate_viewport_notification(this,NOTIFICATION_DRAG_BEGIN);
					}
				}
			}


			if (gui.mouse_focus) {
				over=gui.mouse_focus;
				//recompute focus_inv_xform again here

			} else {

				over = _gui_find_control(mpos);
			}



			if (gui.drag_data.get_type()==Variant::NIL && over && !gui.modal_stack.empty()) {

				Control *top = gui.modal_stack.back()->get();
				if (over!=top && !top->is_a_parent_of(over)) {

					break; // don't send motion event to anything below modal stack top
				}
			}


			if (over!=gui.mouse_over) {

				if (gui.mouse_over)
					gui.mouse_over->notification(Control::NOTIFICATION_MOUSE_EXIT);

				_gui_cancel_tooltip();

				if (over)
					over->notification(Control::NOTIFICATION_MOUSE_ENTER);

			}

			gui.mouse_over=over;

			if (gui.drag_preview) {
				gui.drag_preview->set_pos(mpos);
			}

			if (!over) {
				OS::get_singleton()->set_cursor_shape(OS::CURSOR_ARROW);
				break;
			}


			Matrix32 localizer = over->get_global_transform_with_canvas().affine_inverse();
			Size2 pos = localizer.xform(mpos);
			Vector2 speed = localizer.basis_xform(Point2(p_event.mouse_motion.speed_x,p_event.mouse_motion.speed_y));
			Vector2 rel = localizer.basis_xform(Point2(p_event.mouse_motion.relative_x,p_event.mouse_motion.relative_y));


			p_event.mouse_motion.global_x = mpos.x;
			p_event.mouse_motion.global_y = mpos.y;
			p_event.mouse_motion.speed_x=speed.x;
			p_event.mouse_motion.speed_y=speed.y;
			p_event.mouse_motion.relative_x=rel.x;
			p_event.mouse_motion.relative_y=rel.y;

			if (p_event.mouse_motion.button_mask==0) {
				//nothing pressed

				bool can_tooltip=true;

				if (!gui.modal_stack.empty()) {
					if (gui.modal_stack.back()->get()!=over && !gui.modal_stack.back()->get()->is_a_parent_of(over))
						can_tooltip=false;

				}

				bool is_tooltip_shown = false;

				if (gui.tooltip_popup) {
					if (can_tooltip) {
						String tooltip = over->get_tooltip(gui.tooltip->get_global_transform().xform_inv(mpos));

						if (tooltip.length() == 0)
							_gui_cancel_tooltip();
						else if (tooltip == gui.tooltip_label->get_text())
							is_tooltip_shown = true;
					}
					else
						_gui_cancel_tooltip();
				}

				if (can_tooltip && !is_tooltip_shown) {

					gui.tooltip=over;
					gui.tooltip_pos=mpos;//(parent_xform * get_transform()).affine_inverse().xform(pos);
					gui.tooltip_timer=gui.tooltip_delay;

				}
			}


			//pos = gui.focus_inv_xform.xform(pos);


			p_event.mouse_motion.x = pos.x;
			p_event.mouse_motion.y = pos.y;


			Control::CursorShape cursor_shape = over->get_cursor_shape(pos);
			OS::get_singleton()->set_cursor_shape( (OS::CursorShape)cursor_shape );


			if (over->can_process()) {
				_gui_call_input(over,p_event);
			}



			get_tree()->set_input_as_handled();


			if (gui.drag_data.get_type()!=Variant::NIL && p_event.mouse_motion.button_mask&BUTTON_MASK_LEFT) {


				bool can_drop = over->can_drop_data(pos,gui.drag_data);

				if (!can_drop) {
					OS::get_singleton()->set_cursor_shape( OS::CURSOR_FORBIDDEN );
				} else {
					OS::get_singleton()->set_cursor_shape( OS::CURSOR_CAN_DROP );

				}
				//change mouse accordingly i guess
			}

		} break;
		case InputEvent::ACTION:
		case InputEvent::JOYPAD_BUTTON:
		case InputEvent::JOYPAD_MOTION:
		case InputEvent::KEY: {


			if (gui.key_focus && !gui.key_focus->is_visible()) {
				gui.key_focus->release_focus();
			}

			if (gui.key_focus) {				

				gui.key_event_accepted=false;
				if (gui.key_focus->can_process()) {
					gui.key_focus->call_multilevel(SceneStringNames::get_singleton()->_gui_input,p_event);
					if (gui.key_focus) //maybe lost it
						gui.key_focus->emit_signal(SceneStringNames::get_singleton()->gui_input,p_event);
				}


				if (gui.key_event_accepted) {

					get_tree()->set_input_as_handled();
					break;
				}
			}


			if (p_event.is_pressed() && p_event.is_action("ui_cancel") && !gui.modal_stack.empty()) {

				_gui_sort_modal_stack();
				Control *top = gui.modal_stack.back()->get();
				if (!top->data.modal_exclusive) {

					top->notification(Control::NOTIFICATION_MODAL_CLOSE);
					top->_modal_stack_remove();
					top->hide();
				}
			}


			Control * from = gui.key_focus ? gui.key_focus : NULL; //hmm

			//keyboard focus
			//if (from && p_event.key.pressed && !p_event.key.mod.alt && !p_event.key.mod.meta && !p_event.key.mod.command) {

			if (from && p_event.is_pressed()) {
				Control * next=NULL;

				if (p_event.is_action("ui_focus_next")) {

					next = from->find_next_valid_focus();
				}

				if (p_event.is_action("ui_focus_prev")) {

					next = from->find_prev_valid_focus();
				}

				if (p_event.is_action("ui_up")) {

					next = from->_get_focus_neighbour(MARGIN_TOP);
				}

				if (p_event.is_action("ui_left")) {

					next = from->_get_focus_neighbour(MARGIN_LEFT);
				}

				if (p_event.is_action("ui_right")) {

					next = from->_get_focus_neighbour(MARGIN_RIGHT);
				}

				if (p_event.is_action("ui_down")) {

					next = from->_get_focus_neighbour(MARGIN_BOTTOM);
				}


				if (next) {
					next->grab_focus();
					get_tree()->set_input_as_handled();
				}
			}

		} break;
	}
}


List<Control*>::Element* Viewport::_gui_add_root_control(Control* p_control) {

	gui.roots_order_dirty=true;
	return gui.roots.push_back(p_control);
}

List<Control*>::Element* Viewport::_gui_add_subwindow_control(Control* p_control) {

	gui.subwindow_order_dirty=true;
	return gui.subwindows.push_back(p_control);

}

void Viewport::_gui_set_subwindow_order_dirty() {
	gui.subwindow_order_dirty=true;
}

void Viewport::_gui_set_root_order_dirty() {
	gui.roots_order_dirty=true;
}

void Viewport::_gui_remove_modal_control(List<Control*>::Element *MI) {

	gui.modal_stack.erase(MI);
}

void Viewport::_gui_remove_from_modal_stack(List<Control*>::Element *MI,ObjectID p_prev_focus_owner) {

	//transfer the focus stack to the next

	List<Control*>::Element *next = MI->next();

	gui.modal_stack.erase(MI);
	MI=NULL;

	if (p_prev_focus_owner) {

		// for previous window in stack, pass the focus so it feels more
		// natural

		if (!next) { //top of stack

			Object *pfo = ObjectDB::get_instance(p_prev_focus_owner);
			Control *pfoc = pfo->cast_to<Control>();
			if (!pfoc)
				return;

			if (!pfoc->is_inside_tree() || !pfoc->is_visible())
				return;
			pfoc->grab_focus();
		} else {

			next->get()->_modal_set_prev_focus_owner(p_prev_focus_owner);
		}
	}
}

void Viewport::_gui_force_drag(Control *p_base, const Variant& p_data, Control *p_control) {

	ERR_EXPLAIN("Drag data must be a value");
	ERR_FAIL_COND(p_data.get_type()==Variant::NIL);

	gui.drag_data=p_data;
	gui.mouse_focus=NULL;

	if (p_control) {
		_gui_set_drag_preview(p_base,p_control);
	}
}

void Viewport::_gui_set_drag_preview(Control *p_base, Control *p_control) {

	ERR_FAIL_NULL(p_control);
	ERR_FAIL_COND( !((Object*)p_control)->cast_to<Control>());
	ERR_FAIL_COND(p_control->is_inside_tree());
	ERR_FAIL_COND(p_control->get_parent()!=NULL);

	if (gui.drag_preview) {
		memdelete(gui.drag_preview);
	}
	p_control->set_as_toplevel(true);
	p_control->set_pos(gui.last_mouse_pos);
	p_base->get_root_parent_control()->add_child(p_control); //add as child of viewport
	p_control->raise();
	if (gui.drag_preview) {
		memdelete( gui.drag_preview );
	}
	gui.drag_preview=p_control;
}


void Viewport::_gui_remove_root_control(List<Control*>::Element *RI) {

	gui.roots.erase(RI);
}

void Viewport::_gui_remove_subwindow_control(List<Control*>::Element* SI){

	gui.subwindows.erase(SI);
}

void Viewport::_gui_unfocus_control(Control *p_control) {

	if (gui.key_focus==p_control) {
		gui.key_focus->release_focus();
	}
}

void Viewport::_gui_hid_control(Control *p_control) {

	if (gui.mouse_focus == p_control) {
		gui.mouse_focus=NULL;
	}

	/* ???
	if (data.window==p_control) {
		window->drag_data=Variant();
		if (window->drag_preview) {
			memdelete( window->drag_preview);
			window->drag_preview=NULL;
		}
	}
	*/

	if (gui.key_focus == p_control)
		gui.key_focus=NULL;
	if (gui.mouse_over == p_control)
		gui.mouse_over=NULL;
	if (gui.tooltip == p_control)
		gui.tooltip=NULL;
	if (gui.tooltip == p_control) {
		gui.tooltip=NULL;
		_gui_cancel_tooltip();
	}

}

void Viewport::_gui_remove_control(Control *p_control) {


	if (gui.mouse_focus == p_control)
		gui.mouse_focus=NULL;
	if (gui.key_focus == p_control)
		gui.key_focus=NULL;
	if (gui.mouse_over == p_control)
		gui.mouse_over=NULL;
	if (gui.tooltip == p_control)
		gui.tooltip=NULL;
	if (gui.tooltip_popup == p_control) {
		_gui_cancel_tooltip();
	}


}

void Viewport::_gui_remove_focus() {

	if (gui.key_focus) {
		Node *f=gui.key_focus;
		gui.key_focus=NULL;
		f->notification( Control::NOTIFICATION_FOCUS_EXIT,true );


	}
}

bool Viewport::_gui_is_modal_on_top(const Control* p_control) {

	return  (gui.modal_stack.size() && gui.modal_stack.back()->get()==p_control);

}

bool Viewport::_gui_control_has_focus(const Control* p_control) {

	return gui.key_focus==p_control;
}

void Viewport::_gui_control_grab_focus(Control* p_control) {


	//no need for change
	if (gui.key_focus && gui.key_focus==p_control)
		return;

	get_tree()->call_group(SceneTree::GROUP_CALL_REALTIME,"_viewports","_gui_remove_focus");
	gui.key_focus=p_control;
	p_control->notification(Control::NOTIFICATION_FOCUS_ENTER);
	p_control->update();

}

void Viewport::_gui_accept_event() {

	gui.key_event_accepted=true;
	if (is_inside_tree())
		get_tree()->set_input_as_handled();
}


List<Control*>::Element* Viewport::_gui_show_modal(Control* p_control) {

	gui.modal_stack.push_back(p_control);
	if (gui.key_focus)
		p_control->_modal_set_prev_focus_owner(gui.key_focus->get_instance_ID());
	else
		p_control->_modal_set_prev_focus_owner(0);

	return gui.modal_stack.back();
}

Control *Viewport::_gui_get_focus_owner() {

	return gui.key_focus;
}

void Viewport::_gui_grab_click_focus(Control *p_control) {

	if (gui.mouse_focus) {


		if (gui.mouse_focus==p_control)
			return;
		InputEvent ie;
		ie.type=InputEvent::MOUSE_BUTTON;
		InputEventMouseButton &mb=ie.mouse_button;

		//send unclic

		Point2 click =gui.mouse_focus->get_global_transform_with_canvas().affine_inverse().xform(gui.last_mouse_pos);
		mb.x=click.x;
		mb.y=click.y;
		mb.button_index=gui.mouse_focus_button;
		mb.pressed=false;
		gui.mouse_focus->call_deferred(SceneStringNames::get_singleton()->_gui_input,ie);


		gui.mouse_focus=p_control;
		gui.focus_inv_xform=gui.mouse_focus->get_global_transform_with_canvas().affine_inverse();
		click =gui.mouse_focus->get_global_transform_with_canvas().affine_inverse().xform(gui.last_mouse_pos);
		mb.x=click.x;
		mb.y=click.y;
		mb.button_index=gui.mouse_focus_button;
		mb.pressed=true;
		gui.mouse_focus->call_deferred(SceneStringNames::get_singleton()->_gui_input,ie);

	}
}


///////////////////////////////


void Viewport::input(const InputEvent& p_event) {

	ERR_FAIL_COND(!is_inside_tree());


	get_tree()->_call_input_pause(input_group,"_input",p_event); //not a bug, must happen before GUI, order is _input -> gui input -> _unhandled input
	_gui_input_event(p_event);
	//get_tree()->call_group(SceneTree::GROUP_CALL_REVERSE|SceneTree::GROUP_CALL_REALTIME|SceneTree::GROUP_CALL_MULIILEVEL,gui_input_group,"_gui_input",p_event); //special one for GUI, as controls use their own process check
}

void Viewport::unhandled_input(const InputEvent& p_event) {

	ERR_FAIL_COND(!is_inside_tree());


	get_tree()->_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_tree()->input_handled && p_event.type==InputEvent::KEY) {
		get_tree()->_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);
	}


	if (physics_object_picking && !get_tree()->input_handled) {

		if (p_event.type==InputEvent::MOUSE_BUTTON || p_event.type==InputEvent::MOUSE_MOTION || p_event.type==InputEvent::SCREEN_DRAG || p_event.type==InputEvent::SCREEN_TOUCH) {
			physics_picking_events.push_back(p_event);
		}
	}

}

void Viewport::set_use_own_world(bool p_world) {

	if (p_world==own_world.is_valid())
		return;


	if (is_inside_tree())
		_propagate_exit_world(this);

#ifndef _3D_DISABLED
	if (find_world().is_valid() && camera)
		camera->notification(Camera::NOTIFICATION_LOST_CURRENT);
#endif

	if (!p_world)
		own_world=Ref<World>();
	else
		own_world=Ref<World>( memnew( World ));

	if (is_inside_tree())
		_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_tree()) {
		VisualServer::get_singleton()->viewport_set_scenario(viewport,find_world()->get_scenario());
	}

	_update_listener();


}

bool Viewport::is_using_own_world() const {

	return own_world.is_valid();
}

void Viewport::set_attach_to_screen_rect(const Rect2& p_rect) {

	VS::get_singleton()->viewport_attach_to_screen(viewport,p_rect);
	to_screen_rect=p_rect;
}

Rect2 Viewport::get_attach_to_screen_rect() const{

	return to_screen_rect;
}


void Viewport::set_physics_object_picking(bool p_enable) {

	physics_object_picking=p_enable;
	set_fixed_process(physics_object_picking);
	if (!physics_object_picking)
		physics_picking_events.clear();


}


Vector2 Viewport::get_camera_coords(const Vector2 &p_viewport_coords) const {

	Matrix32 xf = get_final_transform();
	return xf.xform(p_viewport_coords);


}

Vector2 Viewport::get_camera_rect_size() const {

	return size;
}


bool Viewport::get_physics_object_picking() {


	return physics_object_picking;
}

bool Viewport::gui_has_modal_stack() const {

	return gui.modal_stack.size();
}

void Viewport::set_disable_input(bool p_disable) {
	disable_input=p_disable;
}

bool Viewport::is_input_disabled() const {

	return disable_input;
}

void Viewport::set_disable_3d(bool p_disable) {
	disable_3d=p_disable;
	VS::get_singleton()->viewport_set_disable_3d(viewport,p_disable);
}

bool Viewport::is_3d_disabled() const {

	return disable_3d;
}

Variant Viewport::gui_get_drag_data() const {
	return gui.drag_data;
}

Control *Viewport::get_modal_stack_top() const {
	return gui.modal_stack.size()?gui.modal_stack.back()->get():NULL;
}

String Viewport::get_configuration_warning() const {

	/*if (get_parent() && !get_parent()->cast_to<Control>() && !render_target) {

		return TTR("This viewport is not set as render target. If you intend for it to display its contents directly to the screen, make it a child of a Control so it can obtain a size. Otherwise, make it a RenderTarget and assign its internal texture to some node for display.");
	}*/

	return String();
}

void Viewport::gui_reset_canvas_sort_index()  {
	gui.canvas_sort_index=0;
}
int Viewport::gui_get_canvas_sort_index() {

	return gui.canvas_sort_index++;
}

void Viewport::set_msaa(MSAA p_msaa) {

	ERR_FAIL_INDEX(p_msaa,5);
	if (msaa==p_msaa)
		return;
	msaa=p_msaa;
	VS::get_singleton()->viewport_set_msaa(viewport,VS::ViewportMSAA(p_msaa));
}

Viewport::MSAA Viewport::get_msaa() const {

	return msaa;
}

void Viewport::set_hdr(bool p_hdr) {

	if (hdr==p_hdr)
		return;

	hdr=p_hdr;
	VS::get_singleton()->viewport_set_hdr(viewport,p_hdr);

}

bool Viewport::get_hdr() const{

	return hdr;
}



void Viewport::_bind_methods() {


	ClassDB::bind_method(_MD("set_size","size"), &Viewport::set_size);
	ClassDB::bind_method(_MD("get_size"), &Viewport::get_size);
	ClassDB::bind_method(_MD("set_world_2d","world_2d:World2D"), &Viewport::set_world_2d);
	ClassDB::bind_method(_MD("get_world_2d:World2D"), &Viewport::get_world_2d);
	ClassDB::bind_method(_MD("find_world_2d:World2D"), &Viewport::find_world_2d);
	ClassDB::bind_method(_MD("set_world","world:World"), &Viewport::set_world);
	ClassDB::bind_method(_MD("get_world:World"), &Viewport::get_world);
	ClassDB::bind_method(_MD("find_world:World"), &Viewport::find_world);

	ClassDB::bind_method(_MD("set_canvas_transform","xform"), &Viewport::set_canvas_transform);
	ClassDB::bind_method(_MD("get_canvas_transform"), &Viewport::get_canvas_transform);

	ClassDB::bind_method(_MD("set_global_canvas_transform","xform"), &Viewport::set_global_canvas_transform);
	ClassDB::bind_method(_MD("get_global_canvas_transform"), &Viewport::get_global_canvas_transform);
	ClassDB::bind_method(_MD("get_final_transform"), &Viewport::get_final_transform);

	ClassDB::bind_method(_MD("get_visible_rect"), &Viewport::get_visible_rect);
	ClassDB::bind_method(_MD("set_transparent_background","enable"), &Viewport::set_transparent_background);
	ClassDB::bind_method(_MD("has_transparent_background"), &Viewport::has_transparent_background);

	ClassDB::bind_method(_MD("_parent_visibility_changed"), &Viewport::_parent_visibility_changed);

	ClassDB::bind_method(_MD("_parent_resized"), &Viewport::_parent_resized);
	ClassDB::bind_method(_MD("_vp_input"), &Viewport::_vp_input);
	ClassDB::bind_method(_MD("_vp_input_text","text"), &Viewport::_vp_input_text);
	ClassDB::bind_method(_MD("_vp_unhandled_input"), &Viewport::_vp_unhandled_input);

	ClassDB::bind_method(_MD("set_size_override","enable","size","margin"), &Viewport::set_size_override,DEFVAL(Size2(-1,-1)),DEFVAL(Size2(0,0)));
	ClassDB::bind_method(_MD("get_size_override"), &Viewport::get_size_override);
	ClassDB::bind_method(_MD("is_size_override_enabled"), &Viewport::is_size_override_enabled);
	ClassDB::bind_method(_MD("set_size_override_stretch","enabled"), &Viewport::set_size_override_stretch);
	ClassDB::bind_method(_MD("is_size_override_stretch_enabled"), &Viewport::is_size_override_stretch_enabled);
	ClassDB::bind_method(_MD("queue_screen_capture"), &Viewport::queue_screen_capture);
	ClassDB::bind_method(_MD("get_screen_capture"), &Viewport::get_screen_capture);


	ClassDB::bind_method(_MD("set_vflip","enable"), &Viewport::set_vflip);
	ClassDB::bind_method(_MD("get_vflip"), &Viewport::get_vflip);

	ClassDB::bind_method(_MD("set_clear_on_new_frame","enable"), &Viewport::set_clear_on_new_frame);
	ClassDB::bind_method(_MD("get_clear_on_new_frame"), &Viewport::get_clear_on_new_frame);

	ClassDB::bind_method(_MD("clear"), &Viewport::clear);
	ClassDB::bind_method(_MD("set_update_mode","mode"), &Viewport::set_update_mode);
	ClassDB::bind_method(_MD("get_update_mode"), &Viewport::get_update_mode);

	ClassDB::bind_method(_MD("set_msaa","msaa"), &Viewport::set_msaa);
	ClassDB::bind_method(_MD("get_msaa"), &Viewport::get_msaa);

	ClassDB::bind_method(_MD("set_hdr","enable"), &Viewport::set_hdr);
	ClassDB::bind_method(_MD("get_hdr"), &Viewport::get_hdr);

	ClassDB::bind_method(_MD("get_texture:ViewportTexture"), &Viewport::get_texture);

	ClassDB::bind_method(_MD("set_physics_object_picking","enable"), &Viewport::set_physics_object_picking);
	ClassDB::bind_method(_MD("get_physics_object_picking"), &Viewport::get_physics_object_picking);

	ClassDB::bind_method(_MD("get_viewport"), &Viewport::get_viewport);
	ClassDB::bind_method(_MD("input","local_event"), &Viewport::input);
	ClassDB::bind_method(_MD("unhandled_input","local_event"), &Viewport::unhandled_input);

	ClassDB::bind_method(_MD("update_worlds"), &Viewport::update_worlds);

	ClassDB::bind_method(_MD("set_use_own_world","enable"), &Viewport::set_use_own_world);
	ClassDB::bind_method(_MD("is_using_own_world"), &Viewport::is_using_own_world);

	ClassDB::bind_method(_MD("get_camera:Camera"), &Viewport::get_camera);

	ClassDB::bind_method(_MD("set_as_audio_listener","enable"), &Viewport::set_as_audio_listener);
	ClassDB::bind_method(_MD("is_audio_listener","enable"), &Viewport::is_audio_listener);

	ClassDB::bind_method(_MD("set_as_audio_listener_2d","enable"), &Viewport::set_as_audio_listener_2d);
	ClassDB::bind_method(_MD("is_audio_listener_2d","enable"), &Viewport::is_audio_listener_2d);
	ClassDB::bind_method(_MD("set_attach_to_screen_rect","rect"), &Viewport::set_attach_to_screen_rect);

	ClassDB::bind_method(_MD("get_mouse_pos"), &Viewport::get_mouse_pos);
	ClassDB::bind_method(_MD("warp_mouse","to_pos"), &Viewport::warp_mouse);

	ClassDB::bind_method(_MD("gui_has_modal_stack"), &Viewport::gui_has_modal_stack);
	ClassDB::bind_method(_MD("gui_get_drag_data:Variant"), &Viewport::gui_get_drag_data);

	ClassDB::bind_method(_MD("set_disable_input","disable"), &Viewport::set_disable_input);
	ClassDB::bind_method(_MD("is_input_disabled"), &Viewport::is_input_disabled);

	ClassDB::bind_method(_MD("set_disable_3d","disable"), &Viewport::set_disable_3d);
	ClassDB::bind_method(_MD("is_3d_disabled"), &Viewport::is_3d_disabled);

	ClassDB::bind_method(_MD("_gui_show_tooltip"), &Viewport::_gui_show_tooltip);
	ClassDB::bind_method(_MD("_gui_remove_focus"), &Viewport::_gui_remove_focus);

	ClassDB::bind_method(_MD("set_shadow_atlas_size","size"), &Viewport::set_shadow_atlas_size);
	ClassDB::bind_method(_MD("get_shadow_atlas_size"), &Viewport::get_shadow_atlas_size);

	ClassDB::bind_method(_MD("set_shadow_atlas_quadrant_subdiv","quadrant","subdiv"), &Viewport::set_shadow_atlas_quadrant_subdiv);
	ClassDB::bind_method(_MD("get_shadow_atlas_quadrant_subdiv","quadrant"), &Viewport::get_shadow_atlas_quadrant_subdiv);

	ADD_PROPERTY( PropertyInfo(Variant::RECT2,"size"), _SCS("set_size"), _SCS("get_size") );
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"own_world"), _SCS("set_use_own_world"), _SCS("is_using_own_world") );
	ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"world",PROPERTY_HINT_RESOURCE_TYPE,"World"), _SCS("set_world"), _SCS("get_world") );
//	ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"world_2d",PROPERTY_HINT_RESOURCE_TYPE,"World2D"), _SCS("set_world_2d"), _SCS("get_world_2d") );
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"transparent_bg"), _SCS("set_transparent_background"), _SCS("has_transparent_background") );
	ADD_GROUP("Rendering","");
	ADD_PROPERTY( PropertyInfo(Variant::INT,"msaa",PROPERTY_HINT_ENUM,"Disabled,2x,4x,8x,16x"), _SCS("set_msaa"), _SCS("get_msaa") );
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"hdr"), _SCS("set_hdr"), _SCS("get_hdr") );
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"disable_3d"), _SCS("set_disable_3d"), _SCS("is_3d_disabled") );
	ADD_GROUP("Render Target","render_target_");
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"render_target_v_flip"), _SCS("set_vflip"), _SCS("get_vflip") );
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"render_target_clear_on_new_frame"), _SCS("set_clear_on_new_frame"), _SCS("get_clear_on_new_frame") );
	ADD_PROPERTY( PropertyInfo(Variant::INT,"render_target_update_mode",PROPERTY_HINT_ENUM,"Disabled,Once,When Visible,Always"), _SCS("set_update_mode"), _SCS("get_update_mode") );
	ADD_GROUP("Audio Listener","audio_listener_");
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"audio_listener_enable_2d"), _SCS("set_as_audio_listener_2d"), _SCS("is_audio_listener_2d") );
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"audio_listener_enable_3d"), _SCS("set_as_audio_listener"), _SCS("is_audio_listener") );
	ADD_GROUP("Physics","physics_");
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"physics_object_picking"), _SCS("set_physics_object_picking"), _SCS("get_physics_object_picking") );
	ADD_GROUP("GUI","gui_");
	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"gui_disable_input"), _SCS("set_disable_input"), _SCS("is_input_disabled") );
	ADD_GROUP("Shadow Atlas","shadow_atlas_");
	ADD_PROPERTY( PropertyInfo(Variant::INT,"shadow_atlas_size"), _SCS("set_shadow_atlas_size"), _SCS("get_shadow_atlas_size") );
	ADD_PROPERTYI( PropertyInfo(Variant::INT,"shadow_atlas_quad_0",PROPERTY_HINT_ENUM,"Disabled,1 Shadow,4 Shadows,16 Shadows,64 Shadows,256 Shadows,1024 Shadows"), _SCS("set_shadow_atlas_quadrant_subdiv"), _SCS("get_shadow_atlas_quadrant_subdiv"),0 );
	ADD_PROPERTYI( PropertyInfo(Variant::INT,"shadow_atlas_quad_1",PROPERTY_HINT_ENUM,"Disabled,1 Shadow,4 Shadows,16 Shadows,64 Shadows,256 Shadows,1024 Shadows"), _SCS("set_shadow_atlas_quadrant_subdiv"), _SCS("get_shadow_atlas_quadrant_subdiv"),1 );
	ADD_PROPERTYI( PropertyInfo(Variant::INT,"shadow_atlas_quad_2",PROPERTY_HINT_ENUM,"Disabled,1 Shadow,4 Shadows,16 Shadows,64 Shadows,256 Shadows,1024 Shadows"), _SCS("set_shadow_atlas_quadrant_subdiv"), _SCS("get_shadow_atlas_quadrant_subdiv"),2 );
	ADD_PROPERTYI( PropertyInfo(Variant::INT,"shadow_atlas_quad_3",PROPERTY_HINT_ENUM,"Disabled,1 Shadow,4 Shadows,16 Shadows,64 Shadows,256 Shadows,1024 Shadows"), _SCS("set_shadow_atlas_quadrant_subdiv"), _SCS("get_shadow_atlas_quadrant_subdiv"),3 );

	ADD_SIGNAL(MethodInfo("size_changed"));

	BIND_CONSTANT( UPDATE_DISABLED );
	BIND_CONSTANT( UPDATE_ONCE  );
	BIND_CONSTANT( UPDATE_WHEN_VISIBLE  );
	BIND_CONSTANT( UPDATE_ALWAYS  );

	BIND_CONSTANT( SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED );
	BIND_CONSTANT( SHADOW_ATLAS_QUADRANT_SUBDIV_1 );
	BIND_CONSTANT( SHADOW_ATLAS_QUADRANT_SUBDIV_4 );
	BIND_CONSTANT( SHADOW_ATLAS_QUADRANT_SUBDIV_16 );
	BIND_CONSTANT( SHADOW_ATLAS_QUADRANT_SUBDIV_64 );
	BIND_CONSTANT( SHADOW_ATLAS_QUADRANT_SUBDIV_256 );
	BIND_CONSTANT( SHADOW_ATLAS_QUADRANT_SUBDIV_1024 );
	BIND_CONSTANT( SHADOW_ATLAS_QUADRANT_SUBDIV_MAX );

	BIND_CONSTANT( MSAA_DISABLED );
	BIND_CONSTANT( MSAA_2X );
	BIND_CONSTANT( MSAA_4X );
	BIND_CONSTANT( MSAA_8X );
	BIND_CONSTANT( MSAA_16X );

}





Viewport::Viewport() {


	world_2d = Ref<World2D>( memnew( World2D ));

	viewport = VisualServer::get_singleton()->viewport_create();
	texture_rid=VisualServer::get_singleton()->viewport_get_texture(viewport);
	texture_flags=0;

	default_texture.instance();
	default_texture->vp=const_cast<Viewport*>(this);
	viewport_textures.insert(default_texture.ptr());

	internal_listener = SpatialSoundServer::get_singleton()->listener_create();
	audio_listener=false;
	internal_listener_2d = SpatialSound2DServer::get_singleton()->listener_create();
	audio_listener_2d=false;
	transparent_bg=false;
	parent=NULL;
	listener=NULL;
	camera=NULL;
	size_override=false;
	size_override_stretch=false;
	size_override_size=Size2(1,1);
	gen_mipmaps=false;

	vflip=false;
	clear_on_new_frame=true;
	//clear=true;
	update_mode=UPDATE_WHEN_VISIBLE;

	physics_object_picking=false;
	physics_object_capture=0;
	physics_object_over=0;
	physics_last_mousepos=Vector2(1e20,1e20);

	shadow_atlas_size=0;
	for(int i=0;i<4;i++) {
		shadow_atlas_quadrant_subdiv[i]=SHADOW_ATLAS_QUADRANT_SUBDIV_MAX;
	}
	set_shadow_atlas_quadrant_subdiv(0,SHADOW_ATLAS_QUADRANT_SUBDIV_4);
	set_shadow_atlas_quadrant_subdiv(1,SHADOW_ATLAS_QUADRANT_SUBDIV_4);
	set_shadow_atlas_quadrant_subdiv(2,SHADOW_ATLAS_QUADRANT_SUBDIV_16);
	set_shadow_atlas_quadrant_subdiv(3,SHADOW_ATLAS_QUADRANT_SUBDIV_64);


	String id=itos(get_instance_ID());
	input_group = "_vp_input"+id;
	gui_input_group = "_vp_gui_input"+id;
	unhandled_input_group = "_vp_unhandled_input"+id;
	unhandled_key_input_group = "_vp_unhandled_key_input"+id;

	disable_input=false;
	disable_3d=false;

	//window tooltip
	gui.tooltip_timer = -1;

	//gui.tooltip_timer->force_parent_owned();
	gui.tooltip_delay=GLOBAL_DEF("gui/timers/tooltip_delay_sec",0.7);

	gui.tooltip=NULL;
	gui.tooltip_label=NULL;
	gui.drag_preview=NULL;
	gui.drag_attempted=false;
	gui.canvas_sort_index=0;


	msaa=MSAA_DISABLED;
	hdr=false;


}


Viewport::~Viewport() {

	//erase itself from viewport textures
	for(Set<ViewportTexture*>::Element *E=viewport_textures.front();E;E=E->next()) {
		E->get()->vp=NULL;
	}
	VisualServer::get_singleton()->free( viewport );
	SpatialSoundServer::get_singleton()->free(internal_listener);
	SpatialSound2DServer::get_singleton()->free(internal_listener_2d);

}