Drop fully commented-out files

Part of #5272

core/res_ptr.cpp

@@ -1,90 +0,0 @@
-/*************************************************************************/
-/*  res_ptr.cpp                                                          */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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.                */
-/*************************************************************************/
-#if 0
-#include "ref_ptr.h"
-#include "resource.h"
-#include "stdio.h"
-
-void RefPtr::operator=(const RefPtr& p_other) {
-
-	Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
-	Ref<Resource> *ref_other = reinterpret_cast<Ref<Resource>*>( const_cast<char*>(&p_other.data[0]) );
-
-	*ref = *ref_other;
-}
-
-bool RefPtr::operator==(const RefPtr& p_other) const {
-
-	Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
-	Ref<Resource> *ref_other = reinterpret_cast<Ref<Resource>*>( const_cast<char*>(&p_other.data[0]) );
-
-	return *ref == *ref_other;
-}
-
-RefPtr::RefPtr(const RefPtr& p_other) {
-
-	memnew_placement(&data[0],Ref<Resource>);
-
-	Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
-	Ref<Resource> *ref_other = reinterpret_cast<Ref<Resource>*>( const_cast<char*>(&p_other.data[0]) );
-
-	*ref = *ref_other;
-}
-
-bool RefPtr::is_null() const {
-
-	Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
-	return ref->is_null();
-
-
-}
-
-RID RefPtr::get_rid() const {
-
-	Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
-	if (ref->is_null())
-		return RID();
-	return (*ref)->get_rid();
-}
-
-RefPtr::RefPtr() {
-
-	ERR_FAIL_COND(sizeof(Ref<Resource>)>DATASIZE);
-	memnew_placement(&data[0],Ref<Resource>);
-}
-
-
-RefPtr::~RefPtr() {
-
-	Ref<Resource> *ref = reinterpret_cast<Ref<Resource>*>( &data[0] );
-	ref->~Ref<Resource>();
-}
-
-
-#endif

core/res_ptr.h

@@ -1,63 +0,0 @@
-/*************************************************************************/
-/*  res_ptr.h                                                            */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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.                */
-/*************************************************************************/
-#ifndef RES_PTR_H
-#define RES_PTR_H
-
-#if 0
-/**
-	@author Juan Linietsky <[email protected]>
- * This class exists to workaround a limitation in C++ but keep the design OK.
- * It's basically an opaque container of a Resource reference, so Variant can use it.
-*/
-
-#include "rid.h"
-
-class ResBase;
-
-class RefPtr {
-friend class ResBase;
-	enum {
-
-		DATASIZE=sizeof(void*)*4
-	};
-
-	mutable char data[DATASIZE]; // too much probably, virtual class + pointer
-public:
-
-	bool is_null() const;
-	void operator=(const RefPtr& p_other);
-	bool operator==(const RefPtr& p_other) const;
-	RID get_rid() const;
-	RefPtr(const RefPtr& p_other);
-	RefPtr();
-	~RefPtr();
-
-};
-#endif
-#endif

scene/register_scene_types.cpp

@@ -172,7 +172,6 @@
 
 #include "scene/resources/world.h"
 #include "scene/resources/world_2d.h"
-#include "scene/resources/volume.h"
 
 #include "scene/resources/sample_library.h"
 #include "scene/resources/audio_stream.h"
@@ -476,31 +475,10 @@ void register_scene_types() {
 	AcceptDialog::set_swap_ok_cancel( GLOBAL_DEF("display/swap_ok_cancel",bool(OS::get_singleton()->get_swap_ok_cancel())) );
 
 	ObjectTypeDB::register_type<SamplePlayer>();
-
-
-//	ObjectTypeDB::register_type<StaticBody>();
-//	ObjectTypeDB::register_type<RigidBody>();
-//	ObjectTypeDB::register_type<CharacterBody>();
-//	ObjectTypeDB::register_type<BodyVolumeSphere>();
-	//ObjectTypeDB::register_type<BodyVolumeBox>();
-	//ObjectTypeDB::register_type<BodyVolumeCylinder>();
-	//ObjectTypeDB::register_type<BodyVolumeCapsule>();
-	//ObjectTypeDB::register_type<PhysicsJointPin>();
-
-
-
-
 	ObjectTypeDB::register_type<StreamPlayer>();
 	ObjectTypeDB::register_type<EventPlayer>();
 
 
-	/* disable types by default, only editors should enable them */
-	//ObjectTypeDB::set_type_enabled("BodyVolumeSphere",false);
-	//ObjectTypeDB::set_type_enabled("BodyVolumeBox",false);
-	//ObjectTypeDB::set_type_enabled("BodyVolumeCapsule",false);
-	//ObjectTypeDB::set_type_enabled("BodyVolumeCylinder",false);
-	//ObjectTypeDB::set_type_enabled("BodyVolumeConvexPolygon",false);
-
 	ObjectTypeDB::register_type<CanvasItemMaterial>();
 	ObjectTypeDB::register_virtual_type<CanvasItem>();
 	ObjectTypeDB::register_type<Node2D>();
@@ -621,11 +599,11 @@ void register_scene_types() {
 
 	OS::get_singleton()->yield(); //may take time to init
 
-	//ObjectTypeDB::register_type<Volume>();
 	ObjectTypeDB::register_type<Sample>();
 	ObjectTypeDB::register_type<SampleLibrary>();
 	ObjectTypeDB::register_virtual_type<AudioStream>();
 	ObjectTypeDB::register_virtual_type<AudioStreamPlayback>();
+//TODO: Adapt to the new AudioStream API or drop (GH-3307)
 //	ObjectTypeDB::register_type<AudioStreamGibberish>();
 	ObjectTypeDB::register_virtual_type<VideoStream>();
 

scene/resources/gibberish_stream.cpp

@@ -29,6 +29,9 @@
 #include "gibberish_stream.h"
 #include "servers/audio_server.h"
 
+//TODO: This class needs to be adapted to the new AudioStream API,
+// or dropped if nobody cares about fixing it :) (GH-3307)
+
 #if 0
 
 int AudioStreamGibberish::get_channel_count() const {

scene/resources/gibberish_stream.h

@@ -29,6 +29,9 @@
 #ifndef GIBBERISH_STREAM_H
 #define GIBBERISH_STREAM_H
 
+//TODO: This class needs to be adapted to the new AudioStream API,
+// or dropped if nobody cares about fixing it :) (GH-3307)
+
 #if 0
 #include "scene/resources/audio_stream.h"
 #include "scene/resources/sample_library.h"

scene/resources/volume.cpp

@@ -1,211 +0,0 @@
-/*************************************************************************/
-/*  volume.cpp                                                           */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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 "volume.h"
-
-#if 0
-void Volume::_set(const String& p_name, const Variant& p_value) {
-
-
-	if (p_name.begins_with("shapes/")) {
-
-		int idx=p_name.get_slice("/",1).to_int()-1;
-		ERR_FAIL_COND( idx != get_shape_count() );
-
-		Dictionary shape = p_value;
-		ERR_FAIL_COND( !shape.has("type") || !shape.has("data"));
-		String type = shape["type"];
-		Variant data=shape["data"];
-		Transform transform;
-		if (shape.has("transform"))
-			transform=shape["transform"];
-
-		if (type=="plane")
-			add_shape(SHAPE_PLANE,data,transform);
-		else if (type=="sphere")
-			add_shape(SHAPE_SPHERE,data,transform);
-		else if (type=="box")
-			add_shape(SHAPE_BOX,data,transform);
-		else if (type=="cylinder")
-			add_shape(SHAPE_CYLINDER,data,transform);
-		else if (type=="capsule")
-			add_shape(SHAPE_CAPSULE,data,transform);
-		else if (type=="convex_polygon")
-			add_shape(SHAPE_CONVEX_POLYGON,data,transform);
-		else if (type=="concave_polygon")
-			add_shape(SHAPE_CONCAVE_POLYGON,data,transform);
-		else {
-			ERR_FAIL();
-		}
-	}
-}
-
-Variant Volume::_get(const String& p_name) const {
-
-	if (p_name.begins_with("shapes/")) {
-
-		int idx=p_name.get_slice("/",1).to_int()-1;
-		ERR_FAIL_INDEX_V( idx, get_shape_count(), Variant() );
-
-		Dictionary shape;
-
-		switch( get_shape_type(idx) ) {
-
-			case SHAPE_PLANE: shape["type"]="plane"; break;
-			case SHAPE_SPHERE: shape["type"]="sphere"; break;
-			case SHAPE_BOX: shape["type"]="box"; break;
-			case SHAPE_CYLINDER: shape["type"]="cylinder"; break;
-			case SHAPE_CAPSULE: shape["type"]="capsule"; break;
-			case SHAPE_CONVEX_POLYGON: shape["type"]="convex_polygon"; break;
-			case SHAPE_CONCAVE_POLYGON: shape["type"]="concave_polygon"; break;
-
-		}
-
-		shape["transform"]=get_shape_transform(idx);
-		shape["data"]=get_shape(idx);
-
-		return shape;
-	}
-
-	return Variant();
-}
-
-void Volume::_get_property_list( List<PropertyInfo> *p_list) const {
-
-	int count=get_shape_count();
-	for(int i=0;i<count;i++) {
-
-		p_list->push_back( PropertyInfo( Variant::DICTIONARY, "shapes/"+itos(i+1)) );
-	}
-}
-
-
-
-
-
-void Volume::add_shape(ShapeType p_shape_type, const Variant& p_data, const Transform& p_transform) {
-
-	PhysicsServer::get_singleton()->volume_add_shape(volume,(PhysicsServer::ShapeType)p_shape_type,p_data,p_transform);
-	_change_notify();
-}
-
-
-void Volume::add_plane_shape(const Plane& p_plane,const Transform& p_transform) {
-
-	add_shape(SHAPE_PLANE, p_plane, p_transform );
-}
-
-void Volume::add_sphere_shape(float p_radius,const Transform& p_transform) {
-
-	add_shape(SHAPE_SPHERE, p_radius, p_transform );
-}
-
-void Volume::add_box_shape(const Vector3& p_half_extents,const Transform& p_transform) {
-
-	add_shape(SHAPE_BOX, p_half_extents, p_transform );
-}
-void Volume::add_cylinder_shape(float p_radius, float p_height,const Transform& p_transform) {
-
-	Dictionary d;
-	d["radius"]=p_radius;
-	d["height"]=p_height;
-
-	add_shape(SHAPE_CYLINDER,d,p_transform);
-}
-void Volume::add_capsule_shape(float p_radius, float p_height,const Transform& p_transform) {
-
-	Dictionary d;
-	d["radius"]=p_radius;
-	d["height"]=p_height;
-
-	add_shape(SHAPE_CAPSULE,d,p_transform);
-}
-
-
-int Volume::get_shape_count() const {
-
-	return PhysicsServer::get_singleton()->volume_get_shape_count(volume);
-}
-
-Volume::ShapeType Volume::get_shape_type(int p_shape) const {
-
-	return (ShapeType)PhysicsServer::get_singleton()->volume_get_shape_type(volume,p_shape);
-}
-
-Transform Volume::get_shape_transform(int p_shape) const {
-
-	return PhysicsServer::get_singleton()->volume_get_shape_transform(volume,p_shape);
-}
-
-Variant Volume::get_shape(int p_shape) const {
-
-	return PhysicsServer::get_singleton()->volume_get_shape(volume,p_shape);
-}
-
-void Volume::_bind_methods() {
-
-	ObjectTypeDB::bind_method(_MD("add_shape","type","data","transform"),&Volume::add_shape,DEFVAL( Transform() ));
-	ObjectTypeDB::bind_method(_MD("add_plane_shape","plane","transform"),&Volume::add_plane_shape,DEFVAL( Transform() ));
-	ObjectTypeDB::bind_method(_MD("add_sphere_shape"),&Volume::add_sphere_shape,DEFVAL( Transform() ));
-	ObjectTypeDB::bind_method(_MD("add_box_shape","radius","transform"),&Volume::add_box_shape,DEFVAL( Transform() ));
-	ObjectTypeDB::bind_method(_MD("add_cylinder_shape","radius","height","transform"),&Volume::add_cylinder_shape,DEFVAL( Transform() ));
-	ObjectTypeDB::bind_method(_MD("add_capsule_shape","radius","height","transform"),&Volume::add_capsule_shape,DEFVAL( Transform() ));
-	ObjectTypeDB::bind_method(_MD("get_shape_count"),&Volume::get_shape_count);
-	ObjectTypeDB::bind_method(_MD("get_shape_type","shape_idx"),&Volume::get_shape_type);
-	ObjectTypeDB::bind_method(_MD("get_shape_transform","shape_idx"),&Volume::get_shape_transform);
-	ObjectTypeDB::bind_method(_MD("get_shape","shape_idx"),&Volume::get_shape);
-
-	BIND_CONSTANT( SHAPE_PLANE );
-	BIND_CONSTANT( SHAPE_SPHERE );
-	BIND_CONSTANT( SHAPE_BOX );
-	BIND_CONSTANT( SHAPE_CYLINDER );
-	BIND_CONSTANT( SHAPE_CAPSULE );
-	BIND_CONSTANT( SHAPE_CONVEX_POLYGON );
-	BIND_CONSTANT( SHAPE_CONCAVE_POLYGON );
-
-}
-
-RID Volume::get_rid() {
-
-	return volume;
-}
-
-Volume::Volume() {
-
-	volume= PhysicsServer::get_singleton()->volume_create();
-
-}
-
-
-Volume::~Volume() {
-
-	PhysicsServer::get_singleton()->free(volume);
-}
-
-
-#endif

scene/resources/volume.h

@@ -1,86 +0,0 @@
-/*************************************************************************/
-/*  volume.h                                                             */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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.                */
-/*************************************************************************/
-#ifndef VOLUME_H
-#define VOLUME_H
-
-#include "resource.h"
-
-#if 0
-#include "servers/physics_server.h"
-/**
-	@author Juan Linietsky <[email protected]>
-*/
-class Volume : public Resource {
-
-	OBJ_TYPE( Volume, Resource );
-	RID volume;
-
-protected:
-
-	bool _set(const StringName& p_name, const Variant& p_value);
-	bool _get(const StringName& p_name,Variant &r_ret) const;
-	void _get_property_list( List<PropertyInfo> *p_list) const;
-
-	static void _bind_methods();
-public:
-
-	enum ShapeType {
-		SHAPE_PLANE = PhysicsServer::SHAPE_PLANE, ///< plane:"plane"
-		SHAPE_SPHERE = PhysicsServer::SHAPE_SPHERE, ///< float:"radius"
-		SHAPE_BOX = PhysicsServer::SHAPE_BOX, ///< vec3:"extents"
-		SHAPE_CYLINDER = PhysicsServer::SHAPE_CYLINDER, ///< dict(float:"radius", float:"height"):cylinder
-		SHAPE_CAPSULE = PhysicsServer::SHAPE_CAPSULE, ///< dict(float:"radius", float:"height"):capsule
-		SHAPE_CONVEX_POLYGON = PhysicsServer::SHAPE_CONVEX_POLYGON, ///< array of planes:"planes"
-		SHAPE_CONCAVE_POLYGON = PhysicsServer::SHAPE_CONCAVE_POLYGON, ///< vector3 array:"triangles"
-	};
-
-	void add_shape(ShapeType p_shape_type, const Variant& p_data, const Transform& p_transform=Transform ());
-
-	void add_plane_shape(const Plane& p_plane,const Transform& p_transform);
-	void add_sphere_shape(float p_radius,const Transform& p_transform);
-	void add_box_shape(const Vector3& p_half_extents,const Transform& p_transform);
-	void add_cylinder_shape(float p_radius, float p_height,const Transform& p_transform);
-	void add_capsule_shape(float p_radius, float p_height,const Transform& p_transform);
-
-	int get_shape_count() const;
-	ShapeType get_shape_type(int p_shape) const;
-	Transform get_shape_transform(int p_shape) const;
-	Variant get_shape(int p_shape) const;
-
-	virtual RID get_rid();
-
-	Volume();
-	~Volume();
-
-};
-
-VARIANT_ENUM_CAST( Volume::ShapeType );
-
-#endif
-#endif

servers/physics/joints_sw.cpp

@@ -1,450 +0,0 @@
-/*************************************************************************/
-/*  joints_sw.cpp                                                        */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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 "joints_sw.h"
-#include "space_sw.h"
-
-#if 0
-
-//based on chipmunk joint constraints
-
-/* Copyright (c) 2007 Scott Lembcke
- *
- * 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.
- */
-
-static inline real_t k_scalar(Body2DSW *a,Body2DSW *b,const Vector2& rA, const Vector2& rB, const Vector2& n) {
-
-
-	real_t value=0;
-
-
-	{
-		value+=a->get_inv_mass();
-		real_t rcn = rA.cross(n);
-		value+=a->get_inv_inertia() * rcn * rcn;
-	}
-
-	if (b) {
-
-		value+=b->get_inv_mass();
-		real_t rcn = rB.cross(n);
-		value+=b->get_inv_inertia() * rcn * rcn;
-	}
-
-	return value;
-
-}
-
-
-bool PinJoint2DSW::setup(float p_step) {
-
-	Space2DSW *space = A->get_space();
-	ERR_FAIL_COND_V(!space,false;)
-	rA = A->get_transform().xform(anchor_A);
-	rB = B?B->get_transform().xform(anchor_B):anchor_B;
-
-	Vector2 delta = rB - rA;
-
-	rA-= A->get_transform().get_origin();
-	if (B)
-		rB-=B->get_transform().get_origin();
-
-
-	real_t jdist = delta.length();
-	correct=false;
-	if (jdist==0)
-		return false; // do not correct
-
-	correct=true;
-
-	n = delta / jdist;
-
-	// calculate mass normal
-	mass_normal = 1.0f/k_scalar(A, B, rA, rB, n);
-
-	// calculate bias velocity
-	//real_t maxBias = joint->constraint.maxBias;
-	bias = -(get_bias()==0?space->get_constraint_bias():get_bias())*(1.0/p_step)*(jdist-dist);
-	bias = CLAMP(bias, -get_max_bias(), +get_max_bias());
-
-	// compute max impulse
-	jn_max = get_max_force() * p_step;
-
-	// apply accumulated impulse
-	Vector2 j = n * jn_acc;
-	A->apply_impulse(rA,-j);
-	if (B)
-		B->apply_impulse(rB,j);
-
-	return true;
-}
-
-
-static inline Vector2
-relative_velocity(Body2DSW *a, Body2DSW *b, Vector2 rA, Vector2 rB){
-	Vector2 sum = a->get_linear_velocity() -rA.tangent() * a->get_angular_velocity();
-	if (b)
-		return (b->get_linear_velocity() -rB.tangent() * b->get_angular_velocity()) - sum;
-	else
-		return -sum;
-}
-
-static inline real_t
-normal_relative_velocity(Body2DSW *a, Body2DSW *b, Vector2 rA, Vector2 rB, Vector2 n){
-	return relative_velocity(a, b, rA, rB).dot(n);
-}
-
-
-void PinJoint2DSW::solve(float p_step){
-
-	if (!correct)
-		return;
-
-	Vector2 ln = n;
-
-	// compute relative velocity
-	real_t vrn = normal_relative_velocity(A,B, rA, rB, ln);
-
-	// compute normal impulse
-	real_t jn = (bias - vrn)*mass_normal;
-	real_t jnOld = jn_acc;
-	jn_acc = CLAMP(jnOld + jn,-jn_max,jn_max); //cpfclamp(jnOld + jn, -joint->jnMax, joint->jnMax);
-	jn = jn_acc - jnOld;
-
-	Vector2 j = jn*ln;
-
-	A->apply_impulse(rA,-j);
-	if (B)
-		B->apply_impulse(rB,j);
-
-}
-
-
-PinJoint2DSW::PinJoint2DSW(const Vector2& p_pos,Body2DSW* p_body_a,Body2DSW* p_body_b) : Joint2DSW(_arr,p_body_b?2:1) {
-
-	A=p_body_a;
-	B=p_body_b;
-	anchor_A = p_body_a->get_inv_transform().xform(p_pos);
-	anchor_B = p_body_b?p_body_b->get_inv_transform().xform(p_pos):p_pos;
-
-	jn_acc=0;
-	dist=0;
-
-	p_body_a->add_constraint(this,0);
-	if (p_body_b)
-		p_body_b->add_constraint(this,1);
-
-}
-
-PinJoint2DSW::~PinJoint2DSW() {
-
-	if (A)
-		A->remove_constraint(this);
-	if (B)
-		B->remove_constraint(this);
-
-}
-
-//////////////////////////////////////////////
-//////////////////////////////////////////////
-//////////////////////////////////////////////
-
-
-static inline void
-k_tensor(Body2DSW *a, Body2DSW *b, Vector2 r1, Vector2 r2, Vector2 *k1, Vector2 *k2)
-{
-	// calculate mass matrix
-	// If I wasn't lazy and wrote a proper matrix class, this wouldn't be so gross...
-	real_t k11, k12, k21, k22;
-	real_t m_sum = a->get_inv_mass() + b->get_inv_mass();
-
-	// start with I*m_sum
-	k11 = m_sum; k12 = 0.0f;
-	k21 = 0.0f;  k22 = m_sum;
-
-	// add the influence from r1
-	real_t a_i_inv = a->get_inv_inertia();
-	real_t r1xsq =  r1.x * r1.x * a_i_inv;
-	real_t r1ysq =  r1.y * r1.y * a_i_inv;
-	real_t r1nxy = -r1.x * r1.y * a_i_inv;
-	k11 += r1ysq; k12 += r1nxy;
-	k21 += r1nxy; k22 += r1xsq;
-
-	// add the influnce from r2
-	real_t b_i_inv = b->get_inv_inertia();
-	real_t r2xsq =  r2.x * r2.x * b_i_inv;
-	real_t r2ysq =  r2.y * r2.y * b_i_inv;
-	real_t r2nxy = -r2.x * r2.y * b_i_inv;
-	k11 += r2ysq; k12 += r2nxy;
-	k21 += r2nxy; k22 += r2xsq;
-
-	// invert
-	real_t determinant = k11*k22 - k12*k21;
-	ERR_FAIL_COND(determinant== 0.0);
-
-	real_t det_inv = 1.0f/determinant;
-	*k1 = Vector2( k22*det_inv, -k12*det_inv);
-	*k2 = Vector2(-k21*det_inv,  k11*det_inv);
-}
-
-static _FORCE_INLINE_ Vector2
-mult_k(const Vector2& vr, const Vector2 &k1, const Vector2 &k2)
-{
-	return Vector2(vr.dot(k1), vr.dot(k2));
-}
-
-bool GrooveJoint2DSW::setup(float p_step) {
-
-
-	// calculate endpoints in worldspace
-	Vector2 ta = A->get_transform().xform(A_groove_1);
-	Vector2 tb = A->get_transform().xform(A_groove_2);
-	Space2DSW *space=A->get_space();
-
-	// calculate axis
-	Vector2 n = -(tb - ta).tangent().normalized();
-	real_t d = ta.dot(n);
-
-	xf_normal = n;
-	rB = B->get_transform().basis_xform(B_anchor);
-
-	// calculate tangential distance along the axis of rB
-	real_t td = (B->get_transform().get_origin() + rB).cross(n);
-	// calculate clamping factor and rB
-	if(td <= ta.cross(n)){
-		clamp = 1.0f;
-		rA = ta - A->get_transform().get_origin();
-	} else if(td >= tb.cross(n)){
-		clamp = -1.0f;
-		rA = tb - A->get_transform().get_origin();
-	} else {
-		clamp = 0.0f;
-		//joint->r1 = cpvsub(cpvadd(cpvmult(cpvperp(n), -td), cpvmult(n, d)), a->p);
-		rA =  ((-n.tangent() * -td) + n*d) - A->get_transform().get_origin();
-	}
-
-	// Calculate mass tensor
-	k_tensor(A, B, rA, rB, &k1, &k2);
-
-	// compute max impulse
-	jn_max = get_max_force() * p_step;
-
-	// calculate bias velocity
-//	cpVect delta = cpvsub(cpvadd(b->p, joint->r2), cpvadd(a->p, joint->r1));
-//	joint->bias = cpvclamp(cpvmult(delta, -joint->constraint.biasCoef*dt_inv), joint->constraint.maxBias);
-
-
-	Vector2 delta = (B->get_transform().get_origin() +rB) - (A->get_transform().get_origin() + rA);
-	gbias=(delta*-(get_bias()==0?space->get_constraint_bias():get_bias())*(1.0/p_step)).clamped(get_max_bias());
-
-	// apply accumulated impulse
-	A->apply_impulse(rA,-jn_acc);
-	B->apply_impulse(rB,jn_acc);
-
-	correct=true;
-	return true;
-}
-
-void GrooveJoint2DSW::solve(float p_step){
-
-
-	// compute impulse
-	Vector2 vr = relative_velocity(A, B, rA,rB);
-
-	Vector2 j = mult_k(gbias-vr, k1, k2);
-	Vector2 jOld = jn_acc;
-	j+=jOld;
-
-	jn_acc = (((clamp * j.cross(xf_normal)) > 0) ? j : xf_normal.project(j)).clamped(jn_max);
-
-	j = jn_acc - jOld;
-
-	A->apply_impulse(rA,-j);
-	B->apply_impulse(rB,j);
-}
-
-
-GrooveJoint2DSW::GrooveJoint2DSW(const Vector2& p_a_groove1,const Vector2& p_a_groove2, const Vector2& p_b_anchor, Body2DSW* p_body_a,Body2DSW* p_body_b) : Joint2DSW(_arr,2) {
-
-	A=p_body_a;
-	B=p_body_b;
-
-	A_groove_1 = A->get_inv_transform().xform(p_a_groove1);
-	A_groove_2 = A->get_inv_transform().xform(p_a_groove2);
-	B_anchor=B->get_inv_transform().xform(p_b_anchor);
-	A_groove_normal = -(A_groove_2 - A_groove_1).normalized().tangent();
-
-	A->add_constraint(this,0);
-	B->add_constraint(this,1);
-
-}
-
-GrooveJoint2DSW::~GrooveJoint2DSW() {
-
-	A->remove_constraint(this);
-	B->remove_constraint(this);
-}
-
-
-//////////////////////////////////////////////
-//////////////////////////////////////////////
-//////////////////////////////////////////////
-
-
-bool DampedSpringJoint2DSW::setup(float p_step) {
-
-	rA = A->get_transform().basis_xform(anchor_A);
-	rB = B->get_transform().basis_xform(anchor_B);
-
-	Vector2 delta = (B->get_transform().get_origin() + rB) - (A->get_transform().get_origin() + rA) ;
-	real_t dist = delta.length();
-
-	if (dist)
-		n=delta/dist;
-	else
-		n=Vector2();
-
-	real_t k = k_scalar(A, B, rA, rB, n);
-	n_mass = 1.0f/k;
-
-	target_vrn = 0.0f;
-	v_coef = 1.0f - Math::exp(-damping*(p_step)*k);
-
-	// apply spring force
-	real_t f_spring = (rest_length - dist) * stiffness;
-	Vector2 j = n * f_spring*(p_step);
-
-	A->apply_impulse(rA,-j);
-	B->apply_impulse(rB,j);
-
-
-	return true;
-}
-
-void DampedSpringJoint2DSW::solve(float p_step) {
-
-	// compute relative velocity
-	real_t vrn = normal_relative_velocity(A, B, rA, rB, n) - target_vrn;
-
-	// compute velocity loss from drag
-	// not 100% certain this is derived correctly, though it makes sense
-	real_t v_damp = -vrn*v_coef;
-	target_vrn = vrn + v_damp;
-	Vector2 j=n*v_damp*n_mass;
-
-	A->apply_impulse(rA,-j);
-	B->apply_impulse(rB,j);
-
-}
-
-void DampedSpringJoint2DSW::set_param(Physics2DServer::DampedStringParam p_param, real_t p_value) {
-
-	switch(p_param) {
-
-		case Physics2DServer::DAMPED_STRING_REST_LENGTH: {
-
-			rest_length=p_value;
-		} break;
-		case Physics2DServer::DAMPED_STRING_DAMPING: {
-
-			damping=p_value;
-		} break;
-		case Physics2DServer::DAMPED_STRING_STIFFNESS: {
-
-			stiffness=p_value;
-		} break;
-	}
-
-}
-
-real_t DampedSpringJoint2DSW::get_param(Physics2DServer::DampedStringParam p_param) const{
-
-	switch(p_param) {
-
-		case Physics2DServer::DAMPED_STRING_REST_LENGTH: {
-
-			return rest_length;
-		} break;
-		case Physics2DServer::DAMPED_STRING_DAMPING: {
-
-			return damping;
-		} break;
-		case Physics2DServer::DAMPED_STRING_STIFFNESS: {
-
-			return stiffness;
-		} break;
-	}
-
-	ERR_FAIL_V(0);
-}
-
-
-DampedSpringJoint2DSW::DampedSpringJoint2DSW(const Vector2& p_anchor_a,const Vector2& p_anchor_b, Body2DSW* p_body_a,Body2DSW* p_body_b) : Joint2DSW(_arr,2) {
-
-
-	A=p_body_a;
-	B=p_body_b;
-	anchor_A = A->get_inv_transform().xform(p_anchor_a);
-	anchor_B = B->get_inv_transform().xform(p_anchor_b);
-
-	rest_length=p_anchor_a.distance_to(p_anchor_b);
-	stiffness=20;
-	damping=1.5;
-
-
-	A->add_constraint(this,0);
-	B->add_constraint(this,1);
-
-}
-
-DampedSpringJoint2DSW::~DampedSpringJoint2DSW() {
-
-	A->remove_constraint(this);
-	B->remove_constraint(this);
-
-}
-
-
-#endif

servers/physics/joints_sw.h

@@ -33,7 +33,6 @@
 #include "body_sw.h"
 
 
-
 class JointSW : public ConstraintSW {
 
 
@@ -45,122 +44,4 @@ public:
 
 };
 
-#if 0
-class PinJointSW : public JointSW {
-
-	union {
-		struct {
-			BodySW *A;
-			BodySW *B;
-		};
-
-		BodySW *_arr[2];
-	};
-
-	Vector2 anchor_A;
-	Vector2 anchor_B;
-	real_t dist;
-	real_t jn_acc;
-	real_t jn_max;
-	real_t max_distance;
-	real_t mass_normal;
-	real_t bias;
-
-	Vector2 rA,rB;
-	Vector2 n; //normal
-	bool correct;
-
-
-public:
-
-	virtual PhysicsServer::JointType get_type() const { return PhysicsServer::JOINT_PIN; }
-
-	virtual bool setup(float p_step);
-	virtual void solve(float p_step);
-
-
-	PinJointSW(const Vector2& p_pos,BodySW* p_body_a,BodySW* p_body_b=NULL);
-	~PinJointSW();
-};
-
-
-class GrooveJointSW : public JointSW {
-
-	union {
-		struct {
-			BodySW *A;
-			BodySW *B;
-		};
-
-		BodySW *_arr[2];
-	};
-
-	Vector2 A_groove_1;
-	Vector2 A_groove_2;
-	Vector2 A_groove_normal;
-	Vector2 B_anchor;
-	Vector2 jn_acc;
-	Vector2 gbias;
-	real_t jn_max;
-	real_t clamp;
-	Vector2 xf_normal;
-	Vector2 rA,rB;
-	Vector2 k1,k2;
-
-
-	bool correct;
-
-public:
-
-	virtual PhysicsServer::JointType get_type() const { return PhysicsServer::JOINT_GROOVE; }
-
-	virtual bool setup(float p_step);
-	virtual void solve(float p_step);
-
-
-	GrooveJointSW(const Vector2& p_a_groove1,const Vector2& p_a_groove2, const Vector2& p_b_anchor, BodySW* p_body_a,BodySW* p_body_b);
-	~GrooveJointSW();
-};
-
-
-class DampedSpringJointSW : public JointSW {
-
-	union {
-		struct {
-			BodySW *A;
-			BodySW *B;
-		};
-
-		BodySW *_arr[2];
-	};
-
-
-	Vector2 anchor_A;
-	Vector2 anchor_B;
-
-	real_t rest_length;
-	real_t damping;
-	real_t stiffness;
-
-	Vector2 rA,rB;
-	Vector2 n;
-	real_t n_mass;
-	real_t target_vrn;
-	real_t v_coef;
-
-public:
-
-	virtual PhysicsServer::JointType get_type() const { return PhysicsServer::JOINT_DAMPED_SPRING; }
-
-	virtual bool setup(float p_step);
-	virtual void solve(float p_step);
-
-	void set_param(PhysicsServer::DampedStringParam p_param, real_t p_value);
-	real_t get_param(PhysicsServer::DampedStringParam p_param) const;
-
-	DampedSpringJointSW(const Vector2& p_anchor_a,const Vector2& p_anchor_b, BodySW* p_body_a,BodySW* p_body_b);
-	~DampedSpringJointSW();
-};
-#endif
-
-#endif // JOINTS__SW_H
+#endif // JOINTS_SW_H

servers/visual/shader_compiler.cpp

@@ -1,30 +0,0 @@
-/*************************************************************************/
-/*  shader_compiler.cpp                                                  */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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 "shader_compiler.h"
-

servers/visual/shader_compiler.h

@@ -1,142 +0,0 @@
-/*************************************************************************/
-/*  shader_compiler.h                                                    */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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.                */
-/*************************************************************************/
-#ifndef SHADER_COMPILER_H
-#define SHADER_COMPILER_H
-
-#include "map.h"
-#include "list.h"
-#include "vector.h"
-#if 0
-class ShaderSyntax {
-public:
-
-
-	enum DataType {
-		TYPE_BOOL,
-		TYPE_FLOAT,
-		TYPE_VEC3,
-		TYPE_TRANSFORM,
-		TYPE_TEXTURE
-	};
-
-	enum Operator {
-		OP_ASSIGN,
-		OP_ADD,
-		OP_SUB,
-		OP_MUL,
-		OP_DIV,
-		OP_NEG,
-		OP_CMP_EQ,
-		OP_CMP_NEQ,
-		OP_CMP_LEQ,
-		OP_CMP_GEQ,
-		OP_CMP_OR,
-		OP_CMP_AND,
-		OP_CALL
-	};
-
-	struct Node {
-
-		enum Type {
-			TYPE_PROGRAM,
-			TYPE_FUNCTION,
-			TYPE_BLOCK,
-			TYPE_VARIABLE,
-			TYPE_OPERATOR,
-			TYPE_IF,
-		};
-
-		Node * parent;
-		Type type;
-
-		virtual ~Node() {}
-	};
-
-
-	struct OperatorNode : public Node {
-
-		Operator op;
-		Vector<Node*> arguments;
-		OperatorNode() { type=TYPE_OPERATOR; }
-	};
-
-	struct VariableNode : public Node {
-
-		StringName variable;
-		VariableNode() { type=TYPE_VARIABLE; }
-	};
-
-	struct BlockNode : public Node {
-
-		Map<StringName,DataType> variables;
-		List<Node*> subnodes;
-		BlockNode() { type=TYPE_BLOCK; }
-	};
-
-	struct ConditionalNode : public Node {
-
-		Node *test;
-		Node *do_if;
-		Node *do_else;
-		ConditionalNode() { type=TYPE_CONDITIONAL; }
-	};
-
-
-	struct FunctionNode : public Node {
-
-		struct Argument {
-
-			StringName name;
-			DataType type;
-		};
-
-		Vector<Argument> arguments;
-		Node *body;
-
-		FunctionNode() { type=TYPE_FUNCTION; }
-
-	};
-
-
-	struct ProgramNode : public Node {
-
-		Vector<FunctionNode*> functions;
-		Node *body;
-
-		ProgramNode() { type=TYPE_PROGRAM; }
-	};
-
-
-
-
-	ShaderCompiler();
-};
-
-#endif // SHADER_COMPILER_H
-#endif

servers/visual/shader_graph.cpp

@@ -1,455 +0,0 @@
-/*************************************************************************/
-/*  shader_graph.cpp                                                     */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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 "shader_graph.h"
-
-#if 0
-
-
-struct _ConnectionKey {
-
-	int node;
-	int slot;
-
-	_FORCE_INLINE_ _ConnectionKey(int p_node=0,int p_slot=0) { node=p_node; slot=p_slot; }
-
-	_FORCE_INLINE_ bool operator<(const _ConnectionKey& p_other) const {
-
-		if (node<p_other.node)
-			return true;
-		else if (node>p_other.node)
-			return false;
-		else
-			return slot<p_other.slot;
-	}
-};
-
-Error ShaderGraph::generate(ShaderCodeGenerator * p_generator) const {
-
-	Map<int,Node>::Element *E = node_map.front();
-	int i=0;
-	while(E) {
-
-		E->get().order=i++;
-		E->get().out_valid=false;
-		E->get().in_valid=false;
-		E=E->next();
-	}
-
-	int worst_case=connections.size() * connections.size(); // worst bubble case
-	int iterations=0;
-	int swaps;
-
-	do {
-		swaps=0;
-		const List<Connection>::Element *E=connections.front();
-
-		while(E) {
-
-			const Connection &c = E->get();
-
-			const Node *src = &node_map[c.src_id];
-			const Node *dst = &node_map[c.dst_id];
-
-			if (src->order > dst->order) {
-
-				SWAP(src->order, dst->order);
-				swaps++;
-			}
-
-			E=E->next();
-		}
-
-
-		iterations++;
-
-	} while (iterations<=worst_case && swaps>0);
-
-	ERR_FAIL_COND_V( swaps != 0 , ERR_CYCLIC_LINK );
-
-	//node array
-	Vector<const Node*> nodes;
-	nodes.resize(node_map.size());
-
-	E = node_map.front();
-	while(E) {
-
-		ERR_FAIL_INDEX_V( E->get().order, nodes.size(), ERR_BUG);
-		nodes[E->get().order]=&E->get();
-		E=E->next();
-	}
-
-	//connection set
-
-	Map<_ConnectionKey,int> in_connection_map;
-	Map<_ConnectionKey,List<int> > out_connection_map;
-	Map<_ConnectionKey,int> in_node_map;
-	Map<_ConnectionKey,List<int> > out_node_map;
-
-	const List<Connection>::Element *CE=connections.front();
-	i=0;
-	while(CE) {
-		const Connection &c = CE->get();
-
-		_ConnectionKey in_k;
-		in_k.node=node_map[c.dst_id].order;
-		in_k.slot=c.dst_slot;
-		in_connection_map[in_k]=i;
-		in_node_map[in_k]=node_map[c.src_id].order;
-
-		_ConnectionKey out_k;
-		out_k.node=node_map[c.src_id].order;
-		out_k.slot=c.src_slot;
-		if (!out_connection_map.has(out_k))
-			out_connection_map[out_k]=List<int>();
-		out_connection_map[out_k].push_back(i);
-		if(!out_node_map.has(out_k))
-			out_node_map[out_k]=List<int>();
-		out_node_map[out_k].push_back(node_map[c.dst_id].order);
-
-		i++;
-		CE=CE->next();
-	}
-
-	// validate nodes if they are connected to an output
-
-	for(int i=nodes.size()-1;i>=0;i--) {
-
-		if (VisualServer::shader_get_output_count(nodes[i]->type)==0) {
-			// an actual graph output
-
-			_ConnectionKey in_k;
-			in_k.node=nodes[i]->order;
-			in_k.slot=0;
-
-			if (in_node_map.has(in_k)) {
-				nodes[i]->out_valid=true;
-			}
-		} else {
-			// regular node
-
-			bool valid=false;
-			for(int j=0;j<VS::shader_get_output_count(nodes[i]->type);j++) {
-
-				_ConnectionKey key(nodes[i]->order,j);
-
-				if (out_node_map.has(key)) {
-					for(List<int>::Element *CE=out_node_map[key].front();CE;CE=CE->next()) {
-
-						int to_node=CE->get();
-						ERR_CONTINUE(to_node<0 || to_node >=nodes.size());
-						if (nodes[to_node]->out_valid) {
-							valid=true;
-							break;
-						}
-
-
-					}
-				}
-				if (valid)
-					break;
-
-			}
-
-			nodes[i]->out_valid=valid;
-		}
-	}
-
-	// validate nodes if they are connected to an input
-
-	for(int i=0;i<nodes.size();i++) {
-
-		if (VisualServer::shader_get_input_count(nodes[i]->type)==0) {
-			// an actual graph input
-
-			int out_count=VisualServer::shader_get_output_count(nodes[i]->type);
-
-
-			for(int j=0;j<out_count;j++) {
-
-				_ConnectionKey out_k;
-				out_k.node=nodes[i]->order;
-				out_k.slot=j;
-				if (out_node_map.has(out_k)) {
-					nodes[i]->in_valid=true;
-					break;
-				}
-			}
-
-		} else {
-			// regular node
-			// this is very important.. for a node to be valid, all its inputs need to be valid
-			bool valid=true;
-			for(int j=0;j<VS::shader_get_input_count(nodes[i]->type);j++) {
-
-
-				bool in_valid=false;
-				_ConnectionKey key(nodes[i]->order,j);
-				if (in_node_map.has(key)) {
-
-					int from_node=in_node_map[key];
-					ERR_CONTINUE(from_node<0 || from_node>=nodes.size());
-					if (nodes[from_node]->in_valid)
-						in_valid=true;
-
-				}
-
-				if (!in_valid) {
-					valid=false;
-					break;
-				}
-
-			}
-
-			nodes[i]->in_valid=valid;
-		}
-	}
-
-	// write code
-
-	p_generator->begin();
-
-	for(int i=0;i<nodes.size();i++) {
-
-
-		if (!nodes[i]->out_valid || !nodes[i]->in_valid) // valid in both ways
-			continue; // skip node
-
-		Vector<int> in_indices;
-		in_indices.resize(VS::shader_get_input_count(nodes[i]->type));
-		Vector<int> out_indices;
-		Vector<int> out_slot_indices;
-
-		for(int j=0;j<in_indices.size();j++) {
-
-			_ConnectionKey key(nodes[i]->order,j);
-			if (in_connection_map.has(key))
-				in_indices[j]=in_connection_map[key];
-			else
-				in_indices[j]=-1;
-		}
-
-		for(int j=0;j<VS::shader_get_output_count(nodes[i]->type);j++) {
-
-			_ConnectionKey key(nodes[i]->order,j);
-			if (out_connection_map.has(key)) {
-				for(List<int>::Element *CE=out_connection_map[key].front();CE;CE=CE->next()) {
-
-					out_indices.push_back(CE->get());
-					out_slot_indices.push_back(j);
-				}
-			}
-		}
-
-		Error err = p_generator->add_node(nodes[i]->type,i,nodes[i]->id,nodes[i]->param,in_indices,out_indices,out_slot_indices);
-		ERR_FAIL_COND_V( err, err );
-	}
-
-	p_generator->end();
-
-
-	return OK;
-}
-
-void ShaderGraph::node_add(VS::ShaderNodeType p_type,int p_id) {
-
-
-	ERR_FAIL_COND( node_map.has(p_id ) );
-	ERR_FAIL_INDEX( p_type, VS::NODE_TYPE_MAX );
-	Node node;
-
-	node.type=p_type;
-	node.id=p_id;
-	node.x=0;
-	node.y=0;
-
-	node_map[p_id]=node;
-
-}
-
-void ShaderGraph::node_set_pos(int p_id, int p_x,int p_y) {
-
-	ERR_FAIL_COND(!node_map.has(p_id));
-	node_map[p_id].x=p_x;
-	node_map[p_id].y=p_y;
-}
-int ShaderGraph::node_get_pos_x(int p_id) const {
-
-	ERR_FAIL_COND_V(!node_map.has(p_id),-1);
-	return node_map[p_id].x;
-}
-int ShaderGraph::node_get_pos_y(int p_id) const {
-
-	ERR_FAIL_COND_V(!node_map.has(p_id),-1);
-	return node_map[p_id].y;
-}
-
-void ShaderGraph::node_remove(int p_id) {
-
-	ERR_FAIL_COND(!node_map.has(p_id));
-
-	//erase connections associated with node
-	List<Connection>::Element *N,*E=connections.front();
-	while(E) {
-		N=E->next();
-		const Connection &c = E->get();
-		if (c.src_id==p_id || c.dst_id==p_id) {
-
-			connections.erase(E);
-		}
-		E=N;
-	}
-
-	node_map.erase(p_id);
-}
-
-void ShaderGraph::node_change_type(int p_id, VS::ShaderNodeType p_type) {
-
-	ERR_FAIL_COND(!node_map.has(p_id));
-	node_map[p_id].type=p_type;
-	node_map[p_id].param=Variant();
-
-}
-
-void ShaderGraph::node_set_param(int p_id, const Variant& p_value) {
-
-	ERR_FAIL_COND(!node_map.has(p_id));
-	node_map[p_id].param=p_value;
-}
-
-void ShaderGraph::get_node_list(List<int> *p_node_list) const {
-
-	Map<int,Node>::Element *E = node_map.front();
-
-	while(E) {
-
-		p_node_list->push_back(E->key());
-		E=E->next();
-	}
-}
-
-
-VS::ShaderNodeType ShaderGraph::node_get_type(int p_id) const {
-
-	ERR_FAIL_COND_V(!node_map.has(p_id),VS::NODE_TYPE_MAX);
-	return node_map[p_id].type;
-}
-
-Variant ShaderGraph::node_get_param(int p_id) const {
-
-	ERR_FAIL_COND_V(!node_map.has(p_id),Variant());
-	return node_map[p_id].param;
-}
-
-
-Error ShaderGraph::connect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) {
-
-	ERR_FAIL_COND_V(p_src_id==p_dst_id, ERR_INVALID_PARAMETER);
-	ERR_FAIL_COND_V(!node_map.has(p_src_id), ERR_INVALID_PARAMETER);
-	ERR_FAIL_COND_V(!node_map.has(p_dst_id), ERR_INVALID_PARAMETER);
-	VisualServer::ShaderNodeType type_src=node_map[p_src_id].type;
-	VisualServer::ShaderNodeType type_dst=node_map[p_dst_id].type;
-	ERR_FAIL_INDEX_V( p_src_slot, VisualServer::shader_get_output_count(type_src), ERR_INVALID_PARAMETER );
-	ERR_FAIL_INDEX_V( p_dst_slot, VisualServer::shader_get_input_count(type_dst), ERR_INVALID_PARAMETER );
-	ERR_FAIL_COND_V(VisualServer::shader_is_output_vector(type_src,p_src_slot) != VisualServer::shader_is_input_vector(type_dst,p_dst_slot), ERR_INVALID_PARAMETER );
-
-
-	List<Connection>::Element *E=connections.front();
-	while(E) {
-		const Connection &c = E->get();
-		ERR_FAIL_COND_V(c.dst_slot==p_dst_slot && c.dst_id == p_dst_id, ERR_ALREADY_EXISTS);
-
-		E=E->next();
-	}
-
-	Connection c;
-	c.src_slot=p_src_slot;
-	c.src_id=p_src_id;
-	c.dst_slot=p_dst_slot;
-	c.dst_id=p_dst_id;
-
-	connections.push_back(c);
-
-	return OK;
-}
-
-bool ShaderGraph::is_connected(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) const {
-
-	const List<Connection>::Element *E=connections.front();
-	while(E) {
-		const Connection &c = E->get();
-		if (c.dst_slot==p_dst_slot && c.dst_id == p_dst_id && c.src_slot==p_src_slot && c.src_id == p_src_id)
-			return true;
-
-		E=E->next();
-	}
-
-	return false;
-}
-
-void ShaderGraph::disconnect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) {
-
-	List<Connection>::Element *N,*E=connections.front();
-	while(E) {
-		N=E->next();
-		const Connection &c = E->get();
-		if (c.src_slot==p_src_slot && c.src_id==p_src_id && c.dst_slot==p_dst_slot && c.dst_id == p_dst_id) {
-
-			connections.erase(E);
-		}
-		E=N;
-	}
-
-
-}
-
-
-void ShaderGraph::clear() {
-
-	connections.clear();
-	node_map.clear();
-}
-
-List<ShaderGraph::Connection> ShaderGraph::get_connection_list() const {
-
-	return connections;
-
-}
-
-ShaderGraph::ShaderGraph() {
-
-
-}
-
-
-ShaderGraph::~ShaderGraph() {
-
-}
-
-
-#endif

servers/visual/shader_graph.h

@@ -1,109 +0,0 @@
-/*************************************************************************/
-/*  shader_graph.h                                                       */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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.                */
-/*************************************************************************/
-
-#if 0
-
-/**
-	@author Juan Linietsky <[email protected]>
-*/
-
-#include "servers/visual_server.h"
-#include "map.h"
-
-
-class ShaderCodeGenerator {
-public:
-
-	virtual void begin()=0;
-	virtual Error add_node(VS::ShaderNodeType p_type,int p_node_pos,int p_id,const Variant& p_param,const Vector<int>& p_in_connections,const Vector<int>& p_out_connections,const Vector<int>& p_out_connection_outputs)=0;
-	virtual void end()=0;
-
-	virtual ~ShaderCodeGenerator() {}
-};
-
-class ShaderGraph {
-public:
-
-
-	struct Connection {
-
-		int src_id;
-		int src_slot;
-		int dst_id;
-		int dst_slot;
-	};
-
-private:
-	struct Node {
-
-		int16_t x,y;
-		VS::ShaderNodeType type;
-		Variant param;
-		int id;
-		mutable int order; // used for sorting
-		mutable bool out_valid;
-		mutable bool in_valid;
-	};
-
-	Map<int,Node> node_map;
-
-	List<Connection> connections;
-
-public:
-
-	Error generate(ShaderCodeGenerator * p_generator) const;
-
-	void node_add(VS::ShaderNodeType p_type,int p_id);
-	void node_remove(int p_id);
-	void node_change_type(int p_id, VS::ShaderNodeType p_type);
-	void node_set_param(int p_id, const Variant& p_value);
-
-	void node_set_pos(int p_id, int p_x,int p_y);
-	int node_get_pos_x(int p_id) const;
-	int node_get_pos_y(int p_id) const;
-
-	void get_node_list(List<int> *p_node_list) const;
-	void get_sorted_node_list(List<int> *p_node_list) const;
-	VS::ShaderNodeType node_get_type(int p_id) const;
-	Variant node_get_param(int p_id) const;
-
-	Error connect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot);
-	bool is_connected(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) const;
-	void disconnect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot);
-
-	void clear();
-
-	List<Connection> get_connection_list() const;
-
-
-	ShaderGraph();
-	~ShaderGraph();
-
-};
-#endif

tools/editor/editor_node.cpp

@@ -5224,7 +5224,6 @@ EditorNode::EditorNode() {
 	ObjectTypeDB::set_type_enabled("CollisionShape",true);
 	ObjectTypeDB::set_type_enabled("CollisionShape2D",true);
 	ObjectTypeDB::set_type_enabled("CollisionPolygon2D",true);
-	//ObjectTypeDB::set_type_enabled("BodyVolumeConvexPolygon",true);
 
 	Control *theme_base = memnew( Control );
 	add_child(theme_base);

tools/editor/plugins/control_editor_plugin.cpp

@@ -1,825 +0,0 @@
-/*************************************************************************/
-/*  control_editor_plugin.cpp                                            */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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.                */
-/*************************************************************************/
-#if 0
-#include "control_editor_plugin.h"
-#include "print_string.h"
-#include "editor_node.h"
-#include "os/keyboard.h"
-#include "scene/main/viewport.h"
-
-void ControlEditor::_add_control(Control *p_control,const EditInfo& p_info) {
-
-	if (controls.has(p_control))
-		return;
-
-	controls.insert(p_control,p_info);
-	p_control->call_deferred("connect","visibility_changed",this,"_visibility_changed",varray(p_control->get_instance_ID()));
-}
-
-void ControlEditor::_remove_control(Control *p_control) {
-
-	p_control->call_deferred("disconnect","visibility_changed",this,"_visibility_changed");
-	controls.erase(p_control);
-}
-void ControlEditor::_clear_controls(){
-
-	while(controls.size())
-		_remove_control(controls.front()->key());
-}
-
-void ControlEditor::_visibility_changed(ObjectID p_control) {
-
-	Object *c = ObjectDB::get_instance(p_control);
-	if (!c)
-		return;
-	Control *ct = c->cast_to<Control>();
-	if (!ct)
-		return;
-
-	_remove_control(ct);
-}
-
-
-void ControlEditor::_node_removed(Node *p_node) {
-
-	Control *control = (Control*)p_node; //not a good cast, but safe
-	if (controls.has(control))
-		_remove_control(control);
-
-	if (current_window==p_node) {
-		_clear_controls();
-	}
-	update();
-}
-
-// slow as hell
-Control* ControlEditor::_select_control_at_pos(const Point2& p_pos,Node* p_node) {
-
-	for (int i=p_node->get_child_count()-1;i>=0;i--) {
-
-		Control *r=_select_control_at_pos(p_pos,p_node->get_child(i));
-		if (r)
-			return r;
-	}
-
-	Control *c=p_node->cast_to<Control>();
-
-	if (c) {
-		Rect2 rect = c->get_window_rect();
-		if (c->get_window()==current_window) {
-			rect.pos=transform.xform(rect.pos).floor();
-		}
-		if (rect.has_point(p_pos))
-			return c;
-	}
-
-	return NULL;
-}
-
-
-void ControlEditor::_key_move(const Vector2& p_dir, bool p_snap) {
-
-	if (drag!=DRAG_NONE)
-		return;
-
-	Vector2 motion=p_dir;
-	if (p_snap)
-		motion*=snap_val->get_text().to_double();
-
-	undo_redo->create_action("Edit Control");
-	for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-		Control *control = E->key();
-		undo_redo->add_do_method(control,"set_pos",control->get_pos()+motion);
-		undo_redo->add_undo_method(control,"set_pos",control->get_pos());
-	}
-	undo_redo->commit_action();
-}
-
-
-void ControlEditor::_input_event(InputEvent p_event) {
-
-	if (p_event.type==InputEvent::MOUSE_BUTTON) {
-
-		const InputEventMouseButton &b=p_event.mouse_button;
-
-		if (b.button_index==BUTTON_RIGHT) {
-
-			if (controls.size() && drag!=DRAG_NONE) {
-				//cancel drag
-				for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-					Control *control = E->key();
-					control->set_pos(E->get().drag_pos);
-					control->set_size(E->get().drag_size);
-				}
-
-			} else if (b.pressed) {
-				popup->set_pos(Point2(b.x,b.y));
-				popup->popup();
-			}
-			return;
-		}
-		//if (!controls.size())
-		//	return;
-
-		if (b.button_index!=BUTTON_LEFT)
-			return;
-
-		if (!b.pressed) {
-
-			if (drag!=DRAG_NONE) {
-
-				if (undo_redo) {
-
-					undo_redo->create_action("Edit Control");
-					for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-						Control *control = E->key();
-						undo_redo->add_do_method(control,"set_pos",control->get_pos());
-						undo_redo->add_do_method(control,"set_size",control->get_size());
-						undo_redo->add_undo_method(control,"set_pos",E->get().drag_pos);
-						undo_redo->add_undo_method(control,"set_size",E->get().drag_size);
-					}
-					undo_redo->commit_action();
-				}
-
-				drag=DRAG_NONE;
-
-			}
-			return;
-		}
-
-
-		if (controls.size()==1) {
-			//try single control edit
-			Control *control = controls.front()->key();
-			ERR_FAIL_COND(!current_window);
-
-			Rect2 rect=control->get_window_rect();
-			Point2 ofs=Point2();//get_global_pos();
-			Rect2 draw_rect=Rect2(rect.pos-ofs,rect.size);
-			Point2 click=Point2(b.x,b.y);
-			click = transform.affine_inverse().xform(click);
-			Size2 handle_size=Size2(handle_len,handle_len);
-
-			drag = DRAG_NONE;
-
-			if (Rect2(draw_rect.pos-handle_size,handle_size).has_point(click))
-				drag=DRAG_TOP_LEFT;
-			else if (Rect2(draw_rect.pos+draw_rect.size,handle_size).has_point(click))
-				drag=DRAG_BOTTOM_RIGHT;
-			else if(Rect2(draw_rect.pos+Point2(draw_rect.size.width,-handle_size.y),handle_size).has_point(click))
-				drag=DRAG_TOP_RIGHT;
-			else if (Rect2(draw_rect.pos+Point2(-handle_size.x,draw_rect.size.height),handle_size).has_point(click))
-				drag=DRAG_BOTTOM_LEFT;
-			else if (Rect2(draw_rect.pos+Point2(Math::floor((draw_rect.size.width-handle_size.x)/2.0),-handle_size.height),handle_size).has_point(click))
-				drag=DRAG_TOP;
-			else if( Rect2(draw_rect.pos+Point2(-handle_size.width,Math::floor((draw_rect.size.height-handle_size.y)/2.0)),handle_size).has_point(click))
-				drag=DRAG_LEFT;
-			else if ( Rect2(draw_rect.pos+Point2(Math::floor((draw_rect.size.width-handle_size.x)/2.0),draw_rect.size.height),handle_size).has_point(click))
-				drag=DRAG_BOTTOM;
-			else if( Rect2(draw_rect.pos+Point2(draw_rect.size.width,Math::floor((draw_rect.size.height-handle_size.y)/2.0)),handle_size).has_point(click))
-				drag=DRAG_RIGHT;
-
-			if (drag!=DRAG_NONE) {
-				drag_from=click;
-				controls[control].drag_pos=control->get_pos();
-				controls[control].drag_size=control->get_size();
-				controls[control].drag_limit=drag_from+controls[control].drag_size-control->get_minimum_size();
-				return;
-			}
-
-
-		}
-
-		//multi control edit
-
-		Point2 click=Point2(b.x,b.y);
-		Node* scene = get_scene()->get_root_node()->cast_to<EditorNode>()->get_edited_scene();
-		if (!scene)
-			return;
-		/*
-		if (current_window) {
-			//no window.... ?
-			click-=current_window->get_scroll();
-		}*/
-		Control *c=_select_control_at_pos(click, scene);
-
-		Node* n = c;
-		while ((n && n != scene && n->get_owner() != scene) || (n && !n->is_type("Control"))) {
-			n = n->get_parent();
-		};
-		c = n->cast_to<Control>();
-
-
-		if (b.mod.control) { //additive selection
-
-			if (!c)
-				return; //nothing to add
-
-			if (current_window && controls.size() && c->get_window()!=current_window)
-				return; //cant multiple select from multiple windows
-
-			if (!controls.size())
-				current_window=c->get_window();
-
-			if (controls.has(c)) {
-				//already in here, erase it
-				_remove_control(c);
-				update();
-				return;
-			}
-
-			//check parents!
-			Control *parent = c->get_parent()->cast_to<Control>();
-
-			while(parent) {
-
-				if (controls.has(parent))
-					return; //a parent is already selected, so this is pointless
-				parent=parent->get_parent()->cast_to<Control>();
-			}
-
-			//check childrens of everything!
-			List<Control*> to_erase;
-
-			for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-				parent = E->key()->get_parent()->cast_to<Control>();
-				while(parent) {
-					if (parent==c) {
-						to_erase.push_back(E->key());
-						break;
-					}
-					parent=parent->get_parent()->cast_to<Control>();
-				}
-			}
-
-			while(to_erase.size()) {
-				_remove_control(to_erase.front()->get());
-				to_erase.pop_front();
-			}
-
-			_add_control(c,EditInfo());
-			update();
-		} else {
-			//regular selection
-			if (!c) {
-				_clear_controls();
-				update();
-				return;
-			}
-
-			if (!controls.has(c)) {
-				_clear_controls();
-				current_window=c->get_window();
-				_add_control(c,EditInfo());
-				//reselect
-				if (get_scene()->is_editor_hint()) {
-					get_scene()->get_root_node()->call("edit_node",c);
-				}
-
-			}
-
-
-
-			for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-
-				EditInfo &ei=E->get();
-				Control *control=E->key();
-				ei.drag_pos=control->get_pos();
-				ei.drag_size=control->get_size();
-				ei.drag_limit=drag_from+ei.drag_size-control->get_minimum_size();
-			}
-
-			drag=DRAG_ALL;
-			drag_from=click;
-			update();
-		}
-
-	}
-
-	if (p_event.type==InputEvent::MOUSE_MOTION) {
-
-		const InputEventMouseMotion &m=p_event.mouse_motion;
-
-		if (drag==DRAG_NONE || !current_window)
-			return;
-
-		for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-
-			Control *control = E->key();
-			Point2 control_drag_pos=E->get().drag_pos;
-			Point2 control_drag_size=E->get().drag_size;
-			Point2 control_drag_limit=E->get().drag_limit;
-
-			Point2 pos=Point2(m.x,m.y);
-			pos = transform.affine_inverse().xform(pos);
-
-			switch(drag) {
-				case DRAG_ALL: {
-
-					control->set_pos( snapify(control_drag_pos+(pos-drag_from)) );
-				} break;
-				case DRAG_RIGHT: {
-
-					control->set_size( snapify(Size2(control_drag_size.width+(pos-drag_from).x,control_drag_size.height)) );
-				} break;
-				case DRAG_BOTTOM: {
-
-					control->set_size( snapify(Size2(control_drag_size.width,control_drag_size.height+(pos-drag_from).y)) );
-				} break;
-				case DRAG_BOTTOM_RIGHT: {
-
-					control->set_size( snapify(control_drag_size+(pos-drag_from)) );
-				} break;
-				case DRAG_TOP_LEFT: {
-
-					if(pos.x>control_drag_limit.x)
-						pos.x=control_drag_limit.x;
-					if(pos.y>control_drag_limit.y)
-						pos.y=control_drag_limit.y;
-
-					Point2 old_size = control->get_size();
-					Point2 new_pos = snapify(control_drag_pos+(pos-drag_from));
-					Point2 new_size = old_size + (control->get_pos() - new_pos);
-
-					control->set_pos( new_pos );
-					control->set_size( new_size );
-				} break;
-				case DRAG_TOP: {
-
-					if(pos.y>control_drag_limit.y)
-						pos.y=control_drag_limit.y;
-
-					Point2 old_size = control->get_size();
-					Point2 new_pos = snapify(control_drag_pos+Point2(0,pos.y-drag_from.y));
-					Point2 new_size = old_size + (control->get_pos() - new_pos);
-
-					control->set_pos( new_pos );
-					control->set_size( new_size );
-				} break;
-				case DRAG_LEFT: {
-
-					if(pos.x>control_drag_limit.x)
-						pos.x=control_drag_limit.x;
-
-					Point2 old_size = control->get_size();
-					Point2 new_pos = snapify(control_drag_pos+Point2(pos.x-drag_from.x,0));
-					Point2 new_size = old_size + (control->get_pos() - new_pos);
-
-					control->set_pos( new_pos );
-					control->set_size( new_size );
-
-				} break;
-				case DRAG_TOP_RIGHT: {
-
-					if(pos.y>control_drag_limit.y)
-						pos.y=control_drag_limit.y;
-
-					Point2 old_size = control->get_size();
-					Point2 new_pos = snapify(control_drag_pos+Point2(0,pos.y-drag_from.y));
-
-					float new_size_y = Point2( old_size + (control->get_pos() - new_pos)).y;
-					float new_size_x = snapify(control_drag_size+Point2(pos.x-drag_from.x,0)).x;
-
-					control->set_pos( new_pos );
-					control->set_size( Point2(new_size_x, new_size_y) );
-				} break;
-				case DRAG_BOTTOM_LEFT: {
-
-					if(pos.x>control_drag_limit.x)
-						pos.x=control_drag_limit.x;
-
-					Point2 old_size = control->get_size();
-					Point2 new_pos = snapify(control_drag_pos+Point2(pos.x-drag_from.x,0));
-
-					float new_size_y = snapify(control_drag_size+Point2(0,pos.y-drag_from.y)).y;
-					float new_size_x = Point2( old_size + (control->get_pos() - new_pos)).x;
-
-					control->set_pos( new_pos );
-					control->set_size( Point2(new_size_x, new_size_y) );
-
-
-				} break;
-
-			default:{}
-			}
-		}
-	}
-
-	if (p_event.type==InputEvent::KEY) {
-
-		const InputEventKey &k=p_event.key;
-
-		if (k.pressed) {
-
-			if (k.scancode==KEY_UP)
-				_key_move(Vector2(0,-1),k.mod.shift);
-			else if (k.scancode==KEY_DOWN)
-				_key_move(Vector2(0,1),k.mod.shift);
-			else if (k.scancode==KEY_LEFT)
-				_key_move(Vector2(-1,0),k.mod.shift);
-			else if (k.scancode==KEY_RIGHT)
-				_key_move(Vector2(1,0),k.mod.shift);
-		}
-
-	}
-
-
-}
-
-
-bool ControlEditor::get_remove_list(List<Node*> *p_list) {
-
-	for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-
-		p_list->push_back(E->key());
-	}
-
-	return !p_list->empty();
-}
-
-void ControlEditor::_update_scroll(float) {
-
-	if (updating_scroll)
-		return;
-
-	if (!current_window)
-		return;
-
-	Point2 ofs;
-	ofs.x=h_scroll->get_val();
-	ofs.y=v_scroll->get_val();
-
-//	current_window->set_scroll(-ofs);
-
-	transform=Matrix32();
-
-	transform.scale_basis(Size2(zoom,zoom));
-	transform.elements[2]=-ofs*zoom;
-
-
-	RID viewport = editor->get_scene_root()->get_viewport();
-
-	VisualServer::get_singleton()->viewport_set_global_canvas_transform(viewport,transform);
-
-	update();
-
-}
-
-void ControlEditor::_notification(int p_what) {
-
-	if (p_what==NOTIFICATION_PROCESS) {
-
-		for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-
-			Control *control = E->key();
-			Rect2 r=control->get_window_rect();
-			if (r != E->get().last_rect ) {
-				update();
-				E->get().last_rect=r;
-			}
-		}
-
-	}
-
-	if (p_what==NOTIFICATION_CHILDREN_CONFIGURED) {
-
-		get_scene()->connect("node_removed",this,"_node_removed");
-	}
-
-	if (p_what==NOTIFICATION_DRAW) {
-
-		// TODO fetch the viewport?
-		/*
-		if (!control) {
-			h_scroll->hide();
-			v_scroll->hide();
-			return;
-		}
-		*/
-		_update_scrollbars();
-
-		if (!current_window)
-			return;
-
-		for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-
-			Control *control = E->key();
-
-			Rect2 rect=control->get_window_rect();
-			RID ci=get_canvas_item();
-			VisualServer::get_singleton()->canvas_item_set_clip(ci,true);
-			Point2 ofs=Point2();//get_global_pos();
-			Rect2 draw_rect=Rect2(rect.pos-ofs,rect.size);
-			draw_rect.pos = transform.xform(draw_rect.pos);
-			Color light_edit_color=Color(1.0,0.8,0.8);
-			Color dark_edit_color=Color(0.4,0.1,0.1);
-			Size2 handle_size=Size2(handle_len,handle_len);
-
-#define DRAW_RECT( m_rect, m_color )\
-VisualServer::get_singleton()->canvas_item_add_rect(ci,m_rect,m_color);
-
-#define DRAW_EMPTY_RECT( m_rect, m_color )\
-	DRAW_RECT( Rect2(m_rect.pos,Size2(m_rect.size.width,1)), m_color );\
-	DRAW_RECT(Rect2(Point2(m_rect.pos.x,m_rect.pos.y+m_rect.size.height-1),Size2(m_rect.size.width,1)), m_color);\
-	DRAW_RECT(Rect2(m_rect.pos,Size2(1,m_rect.size.height)), m_color);\
-	DRAW_RECT(Rect2(Point2(m_rect.pos.x+m_rect.size.width-1,m_rect.pos.y),Size2(1,m_rect.size.height)), m_color);
-
-#define DRAW_BORDER_RECT( m_rect, m_border_color,m_color )\
-	DRAW_RECT( m_rect, m_color );\
-	DRAW_EMPTY_RECT( m_rect, m_border_color );
-
-			DRAW_EMPTY_RECT( draw_rect.grow(2), light_edit_color );
-			DRAW_EMPTY_RECT( draw_rect.grow(1), dark_edit_color );
-
-			if (controls.size()==1) {
-				DRAW_BORDER_RECT( Rect2(draw_rect.pos-handle_size,handle_size), light_edit_color,dark_edit_color );
-				DRAW_BORDER_RECT( Rect2(draw_rect.pos+draw_rect.size,handle_size), light_edit_color,dark_edit_color );
-				DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(draw_rect.size.width,-handle_size.y),handle_size), light_edit_color,dark_edit_color );
-				DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(-handle_size.x,draw_rect.size.height),handle_size), light_edit_color,dark_edit_color );
-
-				DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(Math::floor((draw_rect.size.width-handle_size.x)/2.0),-handle_size.height),handle_size), light_edit_color,dark_edit_color );
-				DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(-handle_size.width,Math::floor((draw_rect.size.height-handle_size.y)/2.0)),handle_size), light_edit_color,dark_edit_color );
-				DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(Math::floor((draw_rect.size.width-handle_size.x)/2.0),draw_rect.size.height),handle_size), light_edit_color,dark_edit_color );
-				DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(draw_rect.size.width,Math::floor((draw_rect.size.height-handle_size.y)/2.0)),handle_size), light_edit_color,dark_edit_color );
-			}
-
-			//DRAW_EMPTY_RECT( Rect2( current_window->get_scroll()-Point2(1,1), get_size()+Size2(2,2)), Color(0.8,0.8,1.0,0.8) );
-			E->get().last_rect = rect;
-		}
-	}
-}
-
-void ControlEditor::edit(Control *p_control) {
-
-	drag=DRAG_NONE;
-
-	_clear_controls();
-	_add_control(p_control,EditInfo());
-	current_window=p_control->get_window();
-	update();
-
-}
-
-
-void ControlEditor::_find_controls_span(Node *p_node, Rect2& r_rect) {
-
-	if (!editor->get_scene())
-		return;
-
-	if (p_node!=editor->get_edited_scene() && p_node->get_owner()!=editor->get_edited_scene())
-		return;
-
-	if (p_node->cast_to<Control>()) {
-		Control *c = p_node->cast_to<Control>();
-		if (c->get_viewport() != editor->get_viewport()->get_viewport())
-			return; //bye, it's in another viewport
-
-		if (!c->get_parent_control()) {
-
-			Rect2 span = c->get_subtree_span_rect();
-			r_rect.merge(span);
-		}
-	}
-
-	for(int i=0;i<p_node->get_child_count();i++) {
-
-		_find_controls_span(p_node->get_child(i),r_rect);
-	}
-}
-
-void ControlEditor::_update_scrollbars() {
-
-
-	if (!editor->get_scene()) {
-		h_scroll->hide();
-		v_scroll->hide();
-		return;
-	}
-
-	updating_scroll=true;
-
-
-	Size2 size = get_size();
-	Size2 hmin = h_scroll->get_minimum_size();
-	Size2 vmin = v_scroll->get_minimum_size();
-
-	v_scroll->set_begin( Point2(size.width - vmin.width, 0) );
-	v_scroll->set_end( Point2(size.width, size.height) );
-
-	h_scroll->set_begin( Point2( 0, size.height - hmin.height) );
-	h_scroll->set_end( Point2(size.width-vmin.width, size.height) );
-
-
-	Rect2 local_rect = Rect2(Point2(),get_size()-Size2(vmin.width,hmin.height));
-
-	Rect2 control_rect=local_rect;
-	if (editor->get_edited_scene())
-		_find_controls_span(editor->get_edited_scene(),control_rect);
-	control_rect.pos*=zoom;
-	control_rect.size*=zoom;
-
-	/*
-	for(ControlMap::Element *E=controls.front();E;E=E->next()) {
-
-		Control *control = E->key();
-		Rect2 r = control->get_window()->get_subtree_span_rect();
-		if (E==controls.front()) {
-			control_rect = r.merge(local_rect);
-		} else {
-			control_rect = control_rect.merge(r);
-		}
-	}
-
-	*/
-	Point2 ofs;
-
-
-	if (control_rect.size.height <= local_rect.size.height) {
-
-		v_scroll->hide();
-		ofs.y=0;
-	} else {
-
-		v_scroll->show();
-		v_scroll->set_min(control_rect.pos.y);
-		v_scroll->set_max(control_rect.pos.y+control_rect.size.y);
-		v_scroll->set_page(local_rect.size.y);
-		ofs.y=-v_scroll->get_val();
-	}
-
-	if (control_rect.size.width <= local_rect.size.width) {
-
-		h_scroll->hide();
-		ofs.x=0;
-	} else {
-
-		h_scroll->show();
-		h_scroll->set_min(control_rect.pos.x);
-		h_scroll->set_max(control_rect.pos.x+control_rect.size.x);
-		h_scroll->set_page(local_rect.size.x);
-		ofs.x=-h_scroll->get_val();
-	}
-
-//	transform=Matrix32();
-	transform.elements[2]=ofs*zoom;
-	RID viewport = editor->get_scene_root()->get_viewport();
-	VisualServer::get_singleton()->viewport_set_global_canvas_transform(viewport,transform);
-
-//	transform.scale_basis(Vector2(zoom,zoom));
-	updating_scroll=false;
-
-}
-
-
-Point2i ControlEditor::snapify(const Point2i& p_pos) const {
-
-	bool active=popup->is_item_checked(0);
-	int snap = snap_val->get_text().to_int();
-
-	if (!active || snap<1)
-		return p_pos;
-
-	Point2i pos=p_pos;
-	pos.x-=pos.x%snap;
-	pos.y-=pos.y%snap;
-	return pos;
-
-
-}
-void ControlEditor::_popup_callback(int p_op) {
-
-	switch(p_op) {
-
-		case SNAP_USE: {
-
-			popup->set_item_checked(0,!popup->is_item_checked(0));
-		} break;
-		case SNAP_CONFIGURE: {
-			snap_dialog->popup_centered(Size2(200,85));
-		} break;
-	}
-}
-
-void ControlEditor::_bind_methods() {
-
-	ObjectTypeDB::bind_method("_input_event",&ControlEditor::_input_event);
-	ObjectTypeDB::bind_method("_node_removed",&ControlEditor::_node_removed);
-	ObjectTypeDB::bind_method("_update_scroll",&ControlEditor::_update_scroll);
-	ObjectTypeDB::bind_method("_popup_callback",&ControlEditor::_popup_callback);
-	ObjectTypeDB::bind_method("_visibility_changed",&ControlEditor::_visibility_changed);
-}
-
-ControlEditor::ControlEditor(EditorNode *p_editor) {
-
-	editor=p_editor;
-	h_scroll = memnew( HScrollBar );
-	v_scroll = memnew( VScrollBar );
-
-	add_child(h_scroll);
-	add_child(v_scroll);
-	h_scroll->connect("value_changed", this,"_update_scroll",Vector<Variant>(),true);
-	v_scroll->connect("value_changed", this,"_update_scroll",Vector<Variant>(),true);
-
-
-	updating_scroll=false;
-	set_focus_mode(FOCUS_ALL);
-	handle_len=10;
-
-	popup=memnew( PopupMenu );
-	popup->add_check_item("Use Snap");
-	popup->add_item("Configure Snap..");
-	add_child(popup);
-
-	snap_dialog = memnew( ConfirmationDialog );
-	snap_dialog->get_ok()->hide();
-	snap_dialog->get_cancel()->set_text("Close");
-	add_child(snap_dialog);
-
-	Label *l = memnew(Label);
-	l->set_text("Snap:");
-	l->set_pos(Point2(5,5));
-	snap_dialog->add_child(l);
-
-	snap_val=memnew(LineEdit);
-	snap_val->set_text("5");
-	snap_val->set_anchor(MARGIN_RIGHT,ANCHOR_END);
-	snap_val->set_begin(Point2(15,25));
-	snap_val->set_end(Point2(10,25));
-	snap_dialog->add_child(snap_val);
-
-	popup->connect("item_pressed", this,"_popup_callback");
-	current_window=NULL;
-
-	zoom=0.5;
-}
-
-
-void ControlEditorPlugin::edit(Object *p_object) {
-
-	control_editor->set_undo_redo(&get_undo_redo());
-	control_editor->edit(p_object->cast_to<Control>());
-}
-
-bool ControlEditorPlugin::handles(Object *p_object) const {
-
-	return p_object->is_type("Control");
-}
-
-void ControlEditorPlugin::make_visible(bool p_visible) {
-
-	if (p_visible) {
-		control_editor->show();
-		control_editor->set_process(true);
-	} else {
-
-		control_editor->hide();
-		control_editor->set_process(false);
-	}
-
-}
-
-ControlEditorPlugin::ControlEditorPlugin(EditorNode *p_node) {
-
-	editor=p_node;
-	control_editor = memnew( ControlEditor(editor) );
-	editor->get_viewport()->add_child(control_editor);
-	control_editor->set_area_as_parent_rect();
-	control_editor->hide();
-
-
-
-}
-
-
-ControlEditorPlugin::~ControlEditorPlugin()
-{
-}
-
-
-#endif

tools/editor/plugins/control_editor_plugin.h

@@ -1,141 +0,0 @@
-/*************************************************************************/
-/*  control_editor_plugin.h                                              */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                    http://www.godotengine.org                         */
-/*************************************************************************/
-/* Copyright (c) 2007-2016 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.                */
-/*************************************************************************/
-#ifndef CONTROL_EDITOR_PLUGIN_H
-#define CONTROL_EDITOR_PLUGIN_H
-
-#include "tools/editor/editor_plugin.h"
-#include "tools/editor/editor_node.h"
-/**
-	@author Juan Linietsky <[email protected]>
-*/
-
-#if 0
-class ControlEditor : public Control {
-
-	OBJ_TYPE(ControlEditor, Control );
-
-	EditorNode *editor;
-
-	enum {
-		SNAP_USE,
-		SNAP_CONFIGURE
-	};
-
-	enum DragType {
-		DRAG_NONE,
-		DRAG_LEFT,
-		DRAG_TOP_LEFT,
-		DRAG_TOP,
-		DRAG_TOP_RIGHT,
-		DRAG_RIGHT,
-		DRAG_BOTTOM_RIGHT,
-		DRAG_BOTTOM,
-		DRAG_BOTTOM_LEFT,
-		DRAG_ALL
-	};
-
-	HScrollBar *h_scroll;
-	VScrollBar *v_scroll;
-
-	Matrix32 transform;
-	float zoom;
-
-	Control *current_window;
-	PopupMenu *popup;
-	DragType drag;
-	Point2 drag_from;
-
-	struct EditInfo {
-
-		Point2 drag_pos;
-		Point2 drag_size;
-		Point2 drag_limit;
-		Rect2 last_rect;
-	};
-
-	typedef Map<Control*,EditInfo> ControlMap;
-	ControlMap controls;
-	int handle_len;
-	Control* _select_control_at_pos(const Point2& p_pos,Node* p_node);
-
-	ConfirmationDialog *snap_dialog;
-	LineEdit *snap_val;
-
-	void _add_control(Control *p_control,const EditInfo& p_info);
-	void _remove_control(Control *p_control);
-	void _clear_controls();
-	void _visibility_changed(ObjectID p_control);
-	void _key_move(const Vector2& p_dir, bool p_snap);
-
-
-	Point2i snapify(const Point2i& p_pos) const;
-	void _popup_callback(int p_op);
-	bool updating_scroll;
-	void _update_scroll(float);
-	void _update_scrollbars();
-	UndoRedo *undo_redo;
-
-	void _find_controls_span(Node *p_node, Rect2& r_rect);
-
-protected:
-	void _notification(int p_what);
-	void _input_event(InputEvent p_event);
-	void _node_removed(Node *p_node);
-	static void _bind_methods();
-public:
-
-	bool get_remove_list(List<Node*> *p_list);
-	void set_undo_redo(UndoRedo *p_undo_redo) {undo_redo=p_undo_redo; }
-	void edit(Control *p_control);
-	ControlEditor(EditorNode *p_editor);
-};
-
-class ControlEditorPlugin : public EditorPlugin {
-
-	OBJ_TYPE( ControlEditorPlugin, EditorPlugin );
-
-	ControlEditor *control_editor;
-	EditorNode *editor;
-
-public:
-
-	virtual String get_name() const { return "GUI"; }
-	bool has_main_screen() const { return true; }
-	virtual void edit(Object *p_object);
-	virtual bool handles(Object *p_object) const;
-	virtual void make_visible(bool p_visible);
-	virtual bool get_remove_list(List<Node*> *p_list) { return control_editor->get_remove_list(p_list); }
-
-
-	ControlEditorPlugin(EditorNode *p_node);
-	~ControlEditorPlugin();
-
-};
-#endif
-#endif

tools/editor/plugins/shader_graph_editor_plugin.h

@@ -33,7 +33,6 @@
 #include "tools/editor/editor_plugin.h"
 #include "tools/editor/editor_node.h"
 #include "scene/resources/shader.h"
-#include "servers/visual/shader_graph.h"
 #include "scene/gui/tree.h"
 #include "scene/gui/button.h"
 #include "scene/gui/graph_edit.h"