A Whole New World (clang-format edition)

I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code

1 files changed, 493 insertions, 618 deletions

diff --git a/scene/resources/texture.cpp b/scene/resources/texture.cpp
index 62feb7b37c..f979c5c758 100644
--- a/scene/resources/texture.cpp
+++ b/scene/resources/texture.cpp
@@ -27,213 +27,184 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "texture.h"
-#include "io/image_loader.h"
 #include "core/os/os.h"
-
-
+#include "io/image_loader.h"
 
 Size2 Texture::get_size() const {
 
-	return Size2(get_width(),get_height());
+	return Size2(get_width(), get_height());
 }
 
+void Texture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
 
-void Texture::draw(RID p_canvas_item, const Point2& p_pos, const Color& p_modulate, bool p_transpose) const {
-
-	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item,Rect2( p_pos, get_size()),get_rid(),false,p_modulate,p_transpose);
-
+	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, get_size()), get_rid(), false, p_modulate, p_transpose);
 }
-void Texture::draw_rect(RID p_canvas_item,const Rect2& p_rect, bool p_tile,const Color& p_modulate, bool p_transpose) const {
-
-	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item,p_rect,get_rid(),p_tile,p_modulate,p_transpose);
+void Texture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
 
+	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, get_rid(), p_tile, p_modulate, p_transpose);
 }
-void Texture::draw_rect_region(RID p_canvas_item,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate, bool p_transpose) const{
+void Texture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
 
-	VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item,p_rect,get_rid(),p_src_rect,p_modulate,p_transpose);
+	VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, get_rid(), p_src_rect, p_modulate, p_transpose);
 }
 
-bool Texture::get_rect_region(const Rect2& p_rect, const Rect2& p_src_rect,Rect2& r_rect,Rect2& r_src_rect) const {
+bool Texture::get_rect_region(const Rect2 &p_rect, const Rect2 &p_src_rect, Rect2 &r_rect, Rect2 &r_src_rect) const {
 
-	r_rect=p_rect;
-	r_src_rect=p_src_rect;
+	r_rect = p_rect;
+	r_src_rect = p_src_rect;
 
 	return true;
 }
 
 void Texture::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("get_width"),&Texture::get_width);
-	ClassDB::bind_method(D_METHOD("get_height"),&Texture::get_height);
-	ClassDB::bind_method(D_METHOD("get_size"),&Texture::get_size);
-	ClassDB::bind_method(D_METHOD("has_alpha"),&Texture::has_alpha);
-	ClassDB::bind_method(D_METHOD("set_flags","flags"),&Texture::set_flags);
-	ClassDB::bind_method(D_METHOD("get_flags"),&Texture::get_flags);
-	ClassDB::bind_method(D_METHOD("draw","canvas_item","pos","modulate","transpose"),&Texture::draw,DEFVAL(Color(1,1,1)),DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("draw_rect","canvas_item","rect","tile","modulate","transpose"),&Texture::draw_rect,DEFVAL(Color(1,1,1)),DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("draw_rect_region","canvas_item","rect","src_rect","modulate","transpose"),&Texture::draw_rect_region,DEFVAL(Color(1,1,1)),DEFVAL(false));
-
-	BIND_CONSTANT( FLAG_MIPMAPS );
-	BIND_CONSTANT( FLAG_REPEAT );
-	BIND_CONSTANT( 	FLAG_FILTER );
-	BIND_CONSTANT( FLAG_VIDEO_SURFACE );
-	BIND_CONSTANT( FLAGS_DEFAULT );
-	BIND_CONSTANT( FLAG_ANISOTROPIC_FILTER );
-	BIND_CONSTANT( FLAG_CONVERT_TO_LINEAR );
-	BIND_CONSTANT( FLAG_MIRRORED_REPEAT );
-
+	ClassDB::bind_method(D_METHOD("get_width"), &Texture::get_width);
+	ClassDB::bind_method(D_METHOD("get_height"), &Texture::get_height);
+	ClassDB::bind_method(D_METHOD("get_size"), &Texture::get_size);
+	ClassDB::bind_method(D_METHOD("has_alpha"), &Texture::has_alpha);
+	ClassDB::bind_method(D_METHOD("set_flags", "flags"), &Texture::set_flags);
+	ClassDB::bind_method(D_METHOD("get_flags"), &Texture::get_flags);
+	ClassDB::bind_method(D_METHOD("draw", "canvas_item", "pos", "modulate", "transpose"), &Texture::draw, DEFVAL(Color(1, 1, 1)), DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("draw_rect", "canvas_item", "rect", "tile", "modulate", "transpose"), &Texture::draw_rect, DEFVAL(Color(1, 1, 1)), DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("draw_rect_region", "canvas_item", "rect", "src_rect", "modulate", "transpose"), &Texture::draw_rect_region, DEFVAL(Color(1, 1, 1)), DEFVAL(false));
+
+	BIND_CONSTANT(FLAG_MIPMAPS);
+	BIND_CONSTANT(FLAG_REPEAT);
+	BIND_CONSTANT(FLAG_FILTER);
+	BIND_CONSTANT(FLAG_VIDEO_SURFACE);
+	BIND_CONSTANT(FLAGS_DEFAULT);
+	BIND_CONSTANT(FLAG_ANISOTROPIC_FILTER);
+	BIND_CONSTANT(FLAG_CONVERT_TO_LINEAR);
+	BIND_CONSTANT(FLAG_MIRRORED_REPEAT);
 }
 
 Texture::Texture() {
-
-
-
 }
 
-
-
 /////////////////////
 
-
-
-
-
 void ImageTexture::reload_from_file() {
 
-	String path=get_path();
+	String path = get_path();
 	if (!path.is_resource_file())
 		return;
 
 	uint32_t flags = get_flags();
 	Image img;
 
-	Error err = ImageLoader::load_image(path,&img);
-	ERR_FAIL_COND(err!=OK);
-
-	create_from_image(img,flags);
+	Error err = ImageLoader::load_image(path, &img);
+	ERR_FAIL_COND(err != OK);
 
+	create_from_image(img, flags);
 }
 
-bool ImageTexture::_set(const StringName& p_name, const Variant& p_value) {
+bool ImageTexture::_set(const StringName &p_name, const Variant &p_value) {
 
-	if (p_name=="image" && p_value.get_type()==Variant::IMAGE)
-		create_from_image( p_value,flags );
-	else if (p_name=="flags")
-		if (w*h==0)
-			flags=p_value;
+	if (p_name == "image" && p_value.get_type() == Variant::IMAGE)
+		create_from_image(p_value, flags);
+	else if (p_name == "flags")
+		if (w * h == 0)
+			flags = p_value;
 		else
 			set_flags(p_value);
-	else if (p_name=="size") {
+	else if (p_name == "size") {
 		Size2 s = p_value;
-		w=s.width;
-		h=s.height;
-		VisualServer::get_singleton()->texture_set_size_override(texture,w,h);
-	} else if (p_name=="storage") {
-		storage=Storage(p_value.operator int());
-	} else if (p_name=="lossy_quality") {
-		lossy_storage_quality=p_value;
-	} else if (p_name=="_data") {
+		w = s.width;
+		h = s.height;
+		VisualServer::get_singleton()->texture_set_size_override(texture, w, h);
+	} else if (p_name == "storage") {
+		storage = Storage(p_value.operator int());
+	} else if (p_name == "lossy_quality") {
+		lossy_storage_quality = p_value;
+	} else if (p_name == "_data") {
 		_set_data(p_value);
 	} else
 		return false;
 
 	return true;
-
 }
 
-bool ImageTexture::_get(const StringName& p_name,Variant &r_ret) const {
-
+bool ImageTexture::_get(const StringName &p_name, Variant &r_ret) const {
 
-	if (p_name=="image_data") {
+	if (p_name == "image_data") {
 
-	} else if (p_name=="image")
-		r_ret= get_data();
-	else if (p_name=="flags")
-		r_ret= flags;
-	else if (p_name=="size")
-		r_ret=Size2(w,h);
-	else if (p_name=="storage")
-		r_ret= storage;
-	else if (p_name=="lossy_quality")
-		r_ret= lossy_storage_quality;
+	} else if (p_name == "image")
+		r_ret = get_data();
+	else if (p_name == "flags")
+		r_ret = flags;
+	else if (p_name == "size")
+		r_ret = Size2(w, h);
+	else if (p_name == "storage")
+		r_ret = storage;
+	else if (p_name == "lossy_quality")
+		r_ret = lossy_storage_quality;
 	else
 		return false;
 
 	return true;
 }
 
+void ImageTexture::_get_property_list(List<PropertyInfo> *p_list) const {
 
-
-
-void ImageTexture::_get_property_list( List<PropertyInfo> *p_list) const {
-
-
-	PropertyHint img_hint=PROPERTY_HINT_NONE;
-	if (storage==STORAGE_COMPRESS_LOSSY) {
-		img_hint=PROPERTY_HINT_IMAGE_COMPRESS_LOSSY;
-	} else if (storage==STORAGE_COMPRESS_LOSSLESS) {
-		img_hint=PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS;
+	PropertyHint img_hint = PROPERTY_HINT_NONE;
+	if (storage == STORAGE_COMPRESS_LOSSY) {
+		img_hint = PROPERTY_HINT_IMAGE_COMPRESS_LOSSY;
+	} else if (storage == STORAGE_COMPRESS_LOSSLESS) {
+		img_hint = PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS;
 	}
 
-
-
-	p_list->push_back( PropertyInfo( Variant::INT, "flags", PROPERTY_HINT_FLAGS,"Mipmaps,Repeat,Filter,Anisotropic,sRGB,Mirrored Repeat") );
-	p_list->push_back( PropertyInfo( Variant::IMAGE, "image", img_hint,String::num(lossy_storage_quality)) );
-	p_list->push_back( PropertyInfo( Variant::VECTOR2, "size",PROPERTY_HINT_NONE, ""));
-	p_list->push_back( PropertyInfo( Variant::INT, "storage", PROPERTY_HINT_ENUM,"Uncompressed,Compress Lossy,Compress Lossless"));
-	p_list->push_back( PropertyInfo( Variant::REAL, "lossy_quality", PROPERTY_HINT_RANGE,"0.0,1.0,0.01" ));
+	p_list->push_back(PropertyInfo(Variant::INT, "flags", PROPERTY_HINT_FLAGS, "Mipmaps,Repeat,Filter,Anisotropic,sRGB,Mirrored Repeat"));
+	p_list->push_back(PropertyInfo(Variant::IMAGE, "image", img_hint, String::num(lossy_storage_quality)));
+	p_list->push_back(PropertyInfo(Variant::VECTOR2, "size", PROPERTY_HINT_NONE, ""));
+	p_list->push_back(PropertyInfo(Variant::INT, "storage", PROPERTY_HINT_ENUM, "Uncompressed,Compress Lossy,Compress Lossless"));
+	p_list->push_back(PropertyInfo(Variant::REAL, "lossy_quality", PROPERTY_HINT_RANGE, "0.0,1.0,0.01"));
 }
 
-void ImageTexture::_reload_hook(const RID& p_hook) {
+void ImageTexture::_reload_hook(const RID &p_hook) {
 
-	String path=get_path();
+	String path = get_path();
 	if (!path.is_resource_file())
 		return;
 
 	Image img;
-	Error err = ImageLoader::load_image(path,&img);
+	Error err = ImageLoader::load_image(path, &img);
 
-	ERR_FAIL_COND(err!=OK);
+	ERR_FAIL_COND(err != OK);
 
-
-	VisualServer::get_singleton()->texture_set_data(texture,img);
+	VisualServer::get_singleton()->texture_set_data(texture, img);
 
 	_change_notify();
 }
 
-void ImageTexture::create(int p_width, int p_height,Image::Format p_format,uint32_t p_flags) {
-
-	flags=p_flags;
-	VisualServer::get_singleton()->texture_allocate(texture,p_width, p_height, p_format, p_flags);
-	format=p_format;
-	w=p_width;
-	h=p_height;
+void ImageTexture::create(int p_width, int p_height, Image::Format p_format, uint32_t p_flags) {
 
+	flags = p_flags;
+	VisualServer::get_singleton()->texture_allocate(texture, p_width, p_height, p_format, p_flags);
+	format = p_format;
+	w = p_width;
+	h = p_height;
 }
-void ImageTexture::create_from_image(const Image& p_image,  uint32_t p_flags) {
+void ImageTexture::create_from_image(const Image &p_image, uint32_t p_flags) {
 
-	flags=p_flags;
-	w=p_image.get_width();
-	h=p_image.get_height();
-	format=p_image.get_format();
+	flags = p_flags;
+	w = p_image.get_width();
+	h = p_image.get_height();
+	format = p_image.get_format();
 
-	VisualServer::get_singleton()->texture_allocate(texture,p_image.get_width(),p_image.get_height(), p_image.get_format(), p_flags);
-	VisualServer::get_singleton()->texture_set_data(texture,p_image);
+	VisualServer::get_singleton()->texture_allocate(texture, p_image.get_width(), p_image.get_height(), p_image.get_format(), p_flags);
+	VisualServer::get_singleton()->texture_set_data(texture, p_image);
 	_change_notify();
 }
 
 void ImageTexture::set_flags(uint32_t p_flags) {
 
-
-
-/*	uint32_t cube = flags & FLAG_CUBEMAP;
+	/*	uint32_t cube = flags & FLAG_CUBEMAP;
 	if (flags == p_flags&cube)
 		return;
 
 	flags=p_flags|cube;	*/
-	flags=p_flags;
-	VisualServer::get_singleton()->texture_set_flags(texture,p_flags);
-
+	flags = p_flags;
+	VisualServer::get_singleton()->texture_set_flags(texture, p_flags);
 }
 
 uint32_t ImageTexture::get_flags() const {
@@ -246,24 +217,23 @@ Image::Format ImageTexture::get_format() const {
 	return format;
 }
 
-void ImageTexture::load(const String& p_path) {
-
-    Image img;
-    img.load(p_path);
-    create_from_image(img);
+void ImageTexture::load(const String &p_path) {
 
+	Image img;
+	img.load(p_path);
+	create_from_image(img);
 }
 
-void ImageTexture::set_data(const Image& p_image) {
+void ImageTexture::set_data(const Image &p_image) {
 
-	VisualServer::get_singleton()->texture_set_data(texture,p_image);
+	VisualServer::get_singleton()->texture_set_data(texture, p_image);
 
 	_change_notify();
 }
 
 void ImageTexture::_resource_path_changed() {
 
-	String path=get_path();
+	String path = get_path();
 }
 
 Image ImageTexture::get_data() const {
@@ -281,7 +251,6 @@ int ImageTexture::get_height() const {
 	return h;
 }
 
-
 RID ImageTexture::get_rid() const {
 
 	return texture;
@@ -289,7 +258,7 @@ RID ImageTexture::get_rid() const {
 
 void ImageTexture::fix_alpha_edges() {
 
-	if (format==Image::FORMAT_RGBA8 /*&& !(flags&FLAG_CUBEMAP)*/) {
+	if (format == Image::FORMAT_RGBA8 /*&& !(flags&FLAG_CUBEMAP)*/) {
 
 		Image img = get_data();
 		img.fix_alpha_edges();
@@ -299,7 +268,7 @@ void ImageTexture::fix_alpha_edges() {
 
 void ImageTexture::premultiply_alpha() {
 
-	if (format==Image::FORMAT_RGBA8 /*&& !(flags&FLAG_CUBEMAP)*/) {
+	if (format == Image::FORMAT_RGBA8 /*&& !(flags&FLAG_CUBEMAP)*/) {
 
 		Image img = get_data();
 		img.premultiply_alpha();
@@ -311,69 +280,64 @@ void ImageTexture::normal_to_xy() {
 
 	Image img = get_data();
 	img.normalmap_to_xy();
-	create_from_image(img,flags);
+	create_from_image(img, flags);
 }
 
 void ImageTexture::shrink_x2_and_keep_size() {
 
-	Size2 sizeov=get_size();
+	Size2 sizeov = get_size();
 	Image img = get_data();
-	img.resize(img.get_width()/2,img.get_height()/2,Image::INTERPOLATE_BILINEAR);
-	create_from_image(img,flags);
+	img.resize(img.get_width() / 2, img.get_height() / 2, Image::INTERPOLATE_BILINEAR);
+	create_from_image(img, flags);
 	set_size_override(sizeov);
-
 }
 
 bool ImageTexture::has_alpha() const {
 
-	return ( format==Image::FORMAT_LA8 || format==Image::FORMAT_RGBA8 );
+	return (format == Image::FORMAT_LA8 || format == Image::FORMAT_RGBA8);
 }
 
+void ImageTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
 
-void ImageTexture::draw(RID p_canvas_item, const Point2& p_pos, const Color& p_modulate, bool p_transpose) const {
-
-	if ((w|h)==0)
+	if ((w | h) == 0)
 		return;
-	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item,Rect2( p_pos, Size2(w,h)),texture,false,p_modulate,p_transpose);
-
+	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, Size2(w, h)), texture, false, p_modulate, p_transpose);
 }
-void ImageTexture::draw_rect(RID p_canvas_item,const Rect2& p_rect, bool p_tile,const Color& p_modulate, bool p_transpose) const {
+void ImageTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
 
-	if ((w|h)==0)
+	if ((w | h) == 0)
 		return;
-	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item,p_rect,texture,p_tile,p_modulate,p_transpose);
-
+	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, texture, p_tile, p_modulate, p_transpose);
 }
-void ImageTexture::draw_rect_region(RID p_canvas_item,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate, bool p_transpose) const{
+void ImageTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
 
-	if ((w|h)==0)
+	if ((w | h) == 0)
 		return;
-	VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item,p_rect,texture,p_src_rect,p_modulate,p_transpose);
+	VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, texture, p_src_rect, p_modulate, p_transpose);
 }
 
-void ImageTexture::set_size_override(const Size2& p_size) {
+void ImageTexture::set_size_override(const Size2 &p_size) {
 
-	Size2 s=p_size;
-	if (s.x!=0)
-		w=s.x;
-	if (s.y!=0)
-		h=s.y;
-	VisualServer::get_singleton()->texture_set_size_override(texture,w,h);
+	Size2 s = p_size;
+	if (s.x != 0)
+		w = s.x;
+	if (s.y != 0)
+		h = s.y;
+	VisualServer::get_singleton()->texture_set_size_override(texture, w, h);
 }
 
-void ImageTexture::set_path(const String& p_path,bool p_take_over) {
+void ImageTexture::set_path(const String &p_path, bool p_take_over) {
 
 	if (texture.is_valid()) {
-		VisualServer::get_singleton()->texture_set_path(texture,p_path);
+		VisualServer::get_singleton()->texture_set_path(texture, p_path);
 	}
 
-	Resource::set_path(p_path,p_take_over);
+	Resource::set_path(p_path, p_take_over);
 }
 
-
 void ImageTexture::set_storage(Storage p_storage) {
 
-	storage=p_storage;
+	storage = p_storage;
 }
 
 ImageTexture::Storage ImageTexture::get_storage() const {
@@ -383,7 +347,7 @@ ImageTexture::Storage ImageTexture::get_storage() const {
 
 void ImageTexture::set_lossy_storage_quality(float p_lossy_storage_quality) {
 
-	lossy_storage_quality=p_lossy_storage_quality;
+	lossy_storage_quality = p_lossy_storage_quality;
 }
 
 float ImageTexture::get_lossy_storage_quality() const {
@@ -406,57 +370,50 @@ void ImageTexture::_set_data(Dictionary p_data) {
 
 void ImageTexture::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("create","width","height","format","flags"),&ImageTexture::create,DEFVAL(FLAGS_DEFAULT));
-	ClassDB::bind_method(D_METHOD("create_from_image","image","flags"),&ImageTexture::create_from_image,DEFVAL(FLAGS_DEFAULT));
-	ClassDB::bind_method(D_METHOD("get_format"),&ImageTexture::get_format);
-	ClassDB::bind_method(D_METHOD("load","path"),&ImageTexture::load);
-	ClassDB::bind_method(D_METHOD("set_data","image"),&ImageTexture::set_data);
-	ClassDB::bind_method(D_METHOD("get_data","cube_side"),&ImageTexture::get_data);
-	ClassDB::bind_method(D_METHOD("set_storage","mode"),&ImageTexture::set_storage);
-	ClassDB::bind_method(D_METHOD("get_storage"),&ImageTexture::get_storage);
-	ClassDB::bind_method(D_METHOD("set_lossy_storage_quality","quality"),&ImageTexture::set_lossy_storage_quality);
-	ClassDB::bind_method(D_METHOD("get_lossy_storage_quality"),&ImageTexture::get_lossy_storage_quality);
-	ClassDB::bind_method(D_METHOD("fix_alpha_edges"),&ImageTexture::fix_alpha_edges);
-	ClassDB::bind_method(D_METHOD("premultiply_alpha"),&ImageTexture::premultiply_alpha);
-	ClassDB::bind_method(D_METHOD("normal_to_xy"),&ImageTexture::normal_to_xy);
-	ClassDB::bind_method(D_METHOD("shrink_x2_and_keep_size"),&ImageTexture::shrink_x2_and_keep_size);
-
-	ClassDB::bind_method(D_METHOD("set_size_override","size"),&ImageTexture::set_size_override);
-	ClassDB::set_method_flags(get_class_static(),_scs_create("fix_alpha_edges"),METHOD_FLAGS_DEFAULT|METHOD_FLAG_EDITOR);
-	ClassDB::set_method_flags(get_class_static(),_scs_create("premultiply_alpha"),METHOD_FLAGS_DEFAULT|METHOD_FLAG_EDITOR);
-	ClassDB::set_method_flags(get_class_static(),_scs_create("normal_to_xy"),METHOD_FLAGS_DEFAULT|METHOD_FLAG_EDITOR);
-	ClassDB::set_method_flags(get_class_static(),_scs_create("shrink_x2_and_keep_size"),METHOD_FLAGS_DEFAULT|METHOD_FLAG_EDITOR);
-	ClassDB::bind_method(D_METHOD("_reload_hook","rid"),&ImageTexture::_reload_hook);
-
-
-	BIND_CONSTANT( STORAGE_RAW );
-	BIND_CONSTANT( STORAGE_COMPRESS_LOSSY  );
-	BIND_CONSTANT( STORAGE_COMPRESS_LOSSLESS );
-
-
+	ClassDB::bind_method(D_METHOD("create", "width", "height", "format", "flags"), &ImageTexture::create, DEFVAL(FLAGS_DEFAULT));
+	ClassDB::bind_method(D_METHOD("create_from_image", "image", "flags"), &ImageTexture::create_from_image, DEFVAL(FLAGS_DEFAULT));
+	ClassDB::bind_method(D_METHOD("get_format"), &ImageTexture::get_format);
+	ClassDB::bind_method(D_METHOD("load", "path"), &ImageTexture::load);
+	ClassDB::bind_method(D_METHOD("set_data", "image"), &ImageTexture::set_data);
+	ClassDB::bind_method(D_METHOD("get_data", "cube_side"), &ImageTexture::get_data);
+	ClassDB::bind_method(D_METHOD("set_storage", "mode"), &ImageTexture::set_storage);
+	ClassDB::bind_method(D_METHOD("get_storage"), &ImageTexture::get_storage);
+	ClassDB::bind_method(D_METHOD("set_lossy_storage_quality", "quality"), &ImageTexture::set_lossy_storage_quality);
+	ClassDB::bind_method(D_METHOD("get_lossy_storage_quality"), &ImageTexture::get_lossy_storage_quality);
+	ClassDB::bind_method(D_METHOD("fix_alpha_edges"), &ImageTexture::fix_alpha_edges);
+	ClassDB::bind_method(D_METHOD("premultiply_alpha"), &ImageTexture::premultiply_alpha);
+	ClassDB::bind_method(D_METHOD("normal_to_xy"), &ImageTexture::normal_to_xy);
+	ClassDB::bind_method(D_METHOD("shrink_x2_and_keep_size"), &ImageTexture::shrink_x2_and_keep_size);
+
+	ClassDB::bind_method(D_METHOD("set_size_override", "size"), &ImageTexture::set_size_override);
+	ClassDB::set_method_flags(get_class_static(), _scs_create("fix_alpha_edges"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
+	ClassDB::set_method_flags(get_class_static(), _scs_create("premultiply_alpha"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
+	ClassDB::set_method_flags(get_class_static(), _scs_create("normal_to_xy"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
+	ClassDB::set_method_flags(get_class_static(), _scs_create("shrink_x2_and_keep_size"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
+	ClassDB::bind_method(D_METHOD("_reload_hook", "rid"), &ImageTexture::_reload_hook);
+
+	BIND_CONSTANT(STORAGE_RAW);
+	BIND_CONSTANT(STORAGE_COMPRESS_LOSSY);
+	BIND_CONSTANT(STORAGE_COMPRESS_LOSSLESS);
 }
 
 ImageTexture::ImageTexture() {
 
-	w=h=0;
-	flags=FLAGS_DEFAULT;
+	w = h = 0;
+	flags = FLAGS_DEFAULT;
 	texture = VisualServer::get_singleton()->texture_create();
 	storage = STORAGE_RAW;
-	lossy_storage_quality=0.7;
-
-
+	lossy_storage_quality = 0.7;
 }
 
-
 ImageTexture::~ImageTexture() {
 
-	VisualServer::get_singleton()->free( texture );
+	VisualServer::get_singleton()->free(texture);
 }
 
 //////////////////////////////////////////
 
-
-void StreamTexture::_requested_3d(void* p_ud) {
+void StreamTexture::_requested_3d(void *p_ud) {
 
 	StreamTexture *st = (StreamTexture *)p_ud;
 	Ref<StreamTexture> stex(st);
@@ -464,18 +421,16 @@ void StreamTexture::_requested_3d(void* p_ud) {
 	request_3d_callback(stex);
 }
 
-void StreamTexture::_requested_srgb(void* p_ud) {
+void StreamTexture::_requested_srgb(void *p_ud) {
 
 	StreamTexture *st = (StreamTexture *)p_ud;
 	Ref<StreamTexture> stex(st);
 	ERR_FAIL_COND(!request_srgb_callback);
 	request_srgb_callback(stex);
-
 }
 
-StreamTexture::TextureFormatRequestCallback StreamTexture::request_3d_callback=NULL;
-StreamTexture::TextureFormatRequestCallback StreamTexture::request_srgb_callback=NULL;
-
+StreamTexture::TextureFormatRequestCallback StreamTexture::request_3d_callback = NULL;
+StreamTexture::TextureFormatRequestCallback StreamTexture::request_srgb_callback = NULL;
 
 uint32_t StreamTexture::get_flags() const {
 
@@ -486,81 +441,77 @@ Image::Format StreamTexture::get_format() const {
 	return format;
 }
 
+Error StreamTexture::_load_data(const String &p_path, int &tw, int &th, int &flags, Image &image, int p_size_limit) {
 
-Error StreamTexture::_load_data(const String& p_path,int &tw,int &th,int& flags,Image& image,int p_size_limit) {
-
-
-	FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
-	ERR_FAIL_COND_V(!f,ERR_CANT_OPEN);
+	FileAccess *f = FileAccess::open(p_path, FileAccess::READ);
+	ERR_FAIL_COND_V(!f, ERR_CANT_OPEN);
 
 	uint8_t header[4];
-	f->get_buffer(header,4);
-	if (header[0]!='G' || header[1]!='D' || header[2]!='S' || header[3]!='T') {
+	f->get_buffer(header, 4);
+	if (header[0] != 'G' || header[1] != 'D' || header[2] != 'S' || header[3] != 'T') {
 		memdelete(f);
-		ERR_FAIL_COND_V(header[0]!='G' || header[1]!='D' || header[2]!='S' || header[3]!='T',ERR_FILE_CORRUPT);
+		ERR_FAIL_COND_V(header[0] != 'G' || header[1] != 'D' || header[2] != 'S' || header[3] != 'T', ERR_FILE_CORRUPT);
 	}
 
 	tw = f->get_32();
 	th = f->get_32();
-	flags= f->get_32(); //texture flags!
+	flags = f->get_32(); //texture flags!
 	uint32_t df = f->get_32(); //data format
 
-	print_line("width: "+itos(tw));
-	print_line("height: "+itos(th));
-	print_line("flags: "+itos(flags));
-	print_line("df: "+itos(df));
+	print_line("width: " + itos(tw));
+	print_line("height: " + itos(th));
+	print_line("flags: " + itos(flags));
+	print_line("df: " + itos(df));
 
-
-	if (request_3d_callback && df&FORMAT_BIT_DETECT_3D) {
-		print_line("request detect 3D at "+p_path);
-		VS::get_singleton()->texture_set_detect_3d_callback(texture,_requested_3d,this);
+	if (request_3d_callback && df & FORMAT_BIT_DETECT_3D) {
+		print_line("request detect 3D at " + p_path);
+		VS::get_singleton()->texture_set_detect_3d_callback(texture, _requested_3d, this);
 	} else {
-		print_line("not requesting detect 3D at "+p_path);
-		VS::get_singleton()->texture_set_detect_3d_callback(texture,NULL,NULL);
+		print_line("not requesting detect 3D at " + p_path);
+		VS::get_singleton()->texture_set_detect_3d_callback(texture, NULL, NULL);
 	}
 
-	if (request_srgb_callback && df&FORMAT_BIT_DETECT_SRGB) {
-		print_line("request detect srgb at "+p_path);
-		VS::get_singleton()->texture_set_detect_srgb_callback(texture,_requested_srgb,this);
+	if (request_srgb_callback && df & FORMAT_BIT_DETECT_SRGB) {
+		print_line("request detect srgb at " + p_path);
+		VS::get_singleton()->texture_set_detect_srgb_callback(texture, _requested_srgb, this);
 	} else {
-		VS::get_singleton()->texture_set_detect_srgb_callback(texture,NULL,NULL);
-		print_line("not requesting detect srgb at "+p_path);
+		VS::get_singleton()->texture_set_detect_srgb_callback(texture, NULL, NULL);
+		print_line("not requesting detect srgb at " + p_path);
 	}
 
-	if (!(df&FORMAT_BIT_STREAM)) {
-		p_size_limit=0;
+	if (!(df & FORMAT_BIT_STREAM)) {
+		p_size_limit = 0;
 	}
 
-
-	if (df&FORMAT_BIT_LOSSLESS || df&FORMAT_BIT_LOSSY) {
+	if (df & FORMAT_BIT_LOSSLESS || df & FORMAT_BIT_LOSSY) {
 		//look for a PNG or WEBP file inside
 
-		int sw=tw;
-		int sh=th;
+		int sw = tw;
+		int sh = th;
 
 		uint32_t mipmaps = f->get_32();
 		uint32_t size = f->get_32();
 
-		print_line("mipmaps: "+itos(mipmaps));
+		print_line("mipmaps: " + itos(mipmaps));
 
-		while(mipmaps>1 && p_size_limit>0 && (sw>p_size_limit || sh>p_size_limit)) {
+		while (mipmaps > 1 && p_size_limit > 0 && (sw > p_size_limit || sh > p_size_limit)) {
 
-			f->seek(f->get_pos()+size);
+			f->seek(f->get_pos() + size);
 			mipmaps = f->get_32();
 			size = f->get_32();
 
-			sw=MAX(sw>>1,1);
-			sh=MAX(sh>>1,1);
+			sw = MAX(sw >> 1, 1);
+			sh = MAX(sh >> 1, 1);
 			mipmaps--;
 		}
 
 		//mipmaps need to be read independently, they will be later combined
 		Vector<Image> mipmap_images;
-		int total_size=0;
+		int total_size = 0;
 
-		for(int i=0;i<mipmaps;i++) {
+		for (int i = 0; i < mipmaps; i++) {
 
-			if (i>0) {
+			if (i > 0) {
 				size = f->get_32();
 			}
 
@@ -568,11 +519,11 @@ Error StreamTexture::_load_data(const String& p_path,int &tw,int &th,int& flags,
 			pv.resize(size);
 			{
 				PoolVector<uint8_t>::Write w = pv.write();
-				f->get_buffer(w.ptr(),size);
+				f->get_buffer(w.ptr(), size);
 			}
 
 			Image img;
-			if (df&FORMAT_BIT_LOSSLESS) {
+			if (df & FORMAT_BIT_LOSSLESS) {
 				img = Image::lossless_unpacker(pv);
 			} else {
 				img = Image::lossy_unpacker(pv);
@@ -580,21 +531,20 @@ Error StreamTexture::_load_data(const String& p_path,int &tw,int &th,int& flags,
 
 			if (img.empty()) {
 				memdelete(f);
-				ERR_FAIL_COND_V(img.empty(),ERR_FILE_CORRUPT);
+				ERR_FAIL_COND_V(img.empty(), ERR_FILE_CORRUPT);
 			}
-			total_size+=img.get_data().size();
+			total_size += img.get_data().size();
 
 			mipmap_images.push_back(img);
 		}
 
-		print_line("mipmap read total: "+itos(mipmap_images.size()));
-
+		print_line("mipmap read total: " + itos(mipmap_images.size()));
 
 		memdelete(f); //no longer needed
 
-		if (mipmap_images.size()==1) {
+		if (mipmap_images.size() == 1) {
 
-			image=mipmap_images[0];
+			image = mipmap_images[0];
 			return OK;
 
 		} else {
@@ -602,82 +552,80 @@ Error StreamTexture::_load_data(const String& p_path,int &tw,int &th,int& flags,
 			img_data.resize(total_size);
 
 			{
-				PoolVector<uint8_t>::Write w=img_data.write();
+				PoolVector<uint8_t>::Write w = img_data.write();
 
-				int ofs=0;
-				for(int i=0;i<mipmap_images.size();i++) {
+				int ofs = 0;
+				for (int i = 0; i < mipmap_images.size(); i++) {
 
 					PoolVector<uint8_t> id = mipmap_images[i].get_data();
 					int len = id.size();
 					PoolVector<uint8_t>::Read r = id.read();
-					copymem(&w[ofs],r.ptr(),len);
-					ofs+=len;
+					copymem(&w[ofs], r.ptr(), len);
+					ofs += len;
 				}
 			}
 
-			image = Image(sw,sh,true,mipmap_images[0].get_format(),img_data);
+			image = Image(sw, sh, true, mipmap_images[0].get_format(), img_data);
 			return OK;
 		}
 
 	} else {
 
 		//look for regular format
-		Image::Format format = (Image::Format)(df&FORMAT_MASK_IMAGE_FORMAT);
-		bool mipmaps = df&FORMAT_BIT_HAS_MIPMAPS;
+		Image::Format format = (Image::Format)(df & FORMAT_MASK_IMAGE_FORMAT);
+		bool mipmaps = df & FORMAT_BIT_HAS_MIPMAPS;
 
 		if (!mipmaps) {
-			int size = Image::get_image_data_size(tw,th,format,0);
+			int size = Image::get_image_data_size(tw, th, format, 0);
 
 			PoolVector<uint8_t> img_data;
 			img_data.resize(size);
 
 			{
-				PoolVector<uint8_t>::Write w=img_data.write();
-				f->get_buffer(w.ptr(),size);
+				PoolVector<uint8_t>::Write w = img_data.write();
+				f->get_buffer(w.ptr(), size);
 			}
 
 			memdelete(f);
 
-			image = Image(tw,th,false,format,img_data);
+			image = Image(tw, th, false, format, img_data);
 			return OK;
 		} else {
 
-			int sw=tw;
-			int sh=th;
-
-			int mipmaps = Image::get_image_required_mipmaps(tw,th,format);
-			int total_size = Image::get_image_data_size(tw,th,format,mipmaps);
-			int idx=0;
-			int ofs=0;
+			int sw = tw;
+			int sh = th;
 
+			int mipmaps = Image::get_image_required_mipmaps(tw, th, format);
+			int total_size = Image::get_image_data_size(tw, th, format, mipmaps);
+			int idx = 0;
+			int ofs = 0;
 
-			while(mipmaps>1 && p_size_limit>0 && (sw>p_size_limit || sh>p_size_limit)) {
+			while (mipmaps > 1 && p_size_limit > 0 && (sw > p_size_limit || sh > p_size_limit)) {
 
-				sw=MAX(sw>>1,1);
-				sh=MAX(sh>>1,1);
+				sw = MAX(sw >> 1, 1);
+				sh = MAX(sh >> 1, 1);
 				mipmaps--;
 				idx++;
 			}
 
-			if (idx>0) {
-				ofs=Image::get_image_data_size(tw,th,format,idx-1);
+			if (idx > 0) {
+				ofs = Image::get_image_data_size(tw, th, format, idx - 1);
 			}
 
-			if (total_size - ofs <=0) {
+			if (total_size - ofs <= 0) {
 				memdelete(f);
 				ERR_FAIL_V(ERR_FILE_CORRUPT);
 			}
 
-			f->seek(f->get_pos()+ofs);
-
+			f->seek(f->get_pos() + ofs);
 
 			PoolVector<uint8_t> img_data;
 			img_data.resize(total_size - ofs);
 
 			{
-				PoolVector<uint8_t>::Write w=img_data.write();
-				int bytes = f->get_buffer(w.ptr(),total_size - ofs);
-				print_line("requested read: "+itos(total_size - ofs)+" but got: "+itos(bytes));
+				PoolVector<uint8_t>::Write w = img_data.write();
+				int bytes = f->get_buffer(w.ptr(), total_size - ofs);
+				print_line("requested read: " + itos(total_size - ofs) + " but got: " + itos(bytes));
 
 				memdelete(f);
 
@@ -686,7 +634,7 @@ Error StreamTexture::_load_data(const String& p_path,int &tw,int &th,int& flags,
 				}
 			}
 
-			image = Image(sw,sh,true,format,img_data);
+			image = Image(sw, sh, true, format, img_data);
 
 			return OK;
 		}
@@ -695,23 +643,22 @@ Error StreamTexture::_load_data(const String& p_path,int &tw,int &th,int& flags,
 	return ERR_BUG; //unreachable
 }
 
-Error StreamTexture::load(const String& p_path) {
-
+Error StreamTexture::load(const String &p_path) {
 
-	int lw,lh,lflags;
+	int lw, lh, lflags;
 	Image image;
-	Error err = _load_data(p_path,lw,lh,lflags,image);
+	Error err = _load_data(p_path, lw, lh, lflags, image);
 	if (err)
 		return err;
 
-	VS::get_singleton()->texture_allocate(texture,image.get_width(),image.get_height(),image.get_format(),lflags);
-	VS::get_singleton()->texture_set_data(texture,image);
+	VS::get_singleton()->texture_allocate(texture, image.get_width(), image.get_height(), image.get_format(), lflags);
+	VS::get_singleton()->texture_set_data(texture, image);
 
-	w=lw;
-	h=lh;
-	flags=lflags;
-	path_to_file=p_path;
-	format=image.get_format();
+	w = lw;
+	h = lh;
+	flags = lflags;
+	path_to_file = p_path;
+	format = image.get_format();
 
 	return OK;
 }
@@ -733,26 +680,23 @@ RID StreamTexture::get_rid() const {
 	return texture;
 }
 
+void StreamTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
 
-void StreamTexture::draw(RID p_canvas_item, const Point2& p_pos, const Color& p_modulate, bool p_transpose) const {
-
-	if ((w|h)==0)
+	if ((w | h) == 0)
 		return;
-	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item,Rect2( p_pos, Size2(w,h)),texture,false,p_modulate,p_transpose);
-
+	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, Size2(w, h)), texture, false, p_modulate, p_transpose);
 }
-void StreamTexture::draw_rect(RID p_canvas_item,const Rect2& p_rect, bool p_tile,const Color& p_modulate, bool p_transpose) const {
+void StreamTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
 
-	if ((w|h)==0)
+	if ((w | h) == 0)
 		return;
-	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item,p_rect,texture,p_tile,p_modulate,p_transpose);
-
+	VisualServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, texture, p_tile, p_modulate, p_transpose);
 }
-void StreamTexture::draw_rect_region(RID p_canvas_item,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate, bool p_transpose) const{
+void StreamTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
 
-	if ((w|h)==0)
+	if ((w | h) == 0)
 		return;
-	VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item,p_rect,texture,p_src_rect,p_modulate,p_transpose);
+	VisualServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, texture, p_src_rect, p_modulate, p_transpose);
 }
 
 bool StreamTexture::has_alpha() const {
@@ -765,16 +709,15 @@ Image StreamTexture::get_data() const {
 	return VS::get_singleton()->texture_get_data(texture);
 }
 
-void StreamTexture::set_flags(uint32_t p_flags){
-
+void StreamTexture::set_flags(uint32_t p_flags) {
 }
 
 void StreamTexture::reload_from_file() {
 
 #ifdef TOOLS_ENABLED
 	String ipath = get_import_path();
-	if (ipath.is_resource_file() && ipath!=path_to_file) {
-		path_to_file=ipath;
+	if (ipath.is_resource_file() && ipath != path_to_file) {
+		path_to_file = ipath;
 	}
 #endif
 	load(path_to_file);
@@ -782,19 +725,18 @@ void StreamTexture::reload_from_file() {
 
 void StreamTexture::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("load","path"),&StreamTexture::load);
-	ClassDB::bind_method(D_METHOD("get_load_path"),&StreamTexture::get_load_path);
+	ClassDB::bind_method(D_METHOD("load", "path"), &StreamTexture::load);
+	ClassDB::bind_method(D_METHOD("get_load_path"), &StreamTexture::get_load_path);
 
-	ADD_PROPERTY( PropertyInfo(Variant::STRING,"load_path",PROPERTY_HINT_FILE,"*.stex"),"load","get_load_path");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "load_path", PROPERTY_HINT_FILE, "*.stex"), "load", "get_load_path");
 }
 
-
 StreamTexture::StreamTexture() {
 
-	format=Image::FORMAT_MAX;
-	flags=0;
-	w=0;
-	h=0;
+	format = Image::FORMAT_MAX;
+	flags = 0;
+	w = 0;
+	h = 0;
 
 	texture = VS::get_singleton()->texture_create();
 }
@@ -804,61 +746,53 @@ StreamTexture::~StreamTexture() {
 	VS::get_singleton()->free(texture);
 }
 
-
-
-RES ResourceFormatLoaderStreamTexture::load(const String &p_path,const String& p_original_path,Error *r_error) {
+RES ResourceFormatLoaderStreamTexture::load(const String &p_path, const String &p_original_path, Error *r_error) {
 
 	Ref<StreamTexture> st;
 	st.instance();
 	Error err = st->load(p_path);
 	if (r_error)
-		*r_error=err;
-	if (err!=OK)
+		*r_error = err;
+	if (err != OK)
 		return RES();
 
 	return st;
 }
 
-void ResourceFormatLoaderStreamTexture::get_recognized_extensions(List<String> *p_extensions) const{
+void ResourceFormatLoaderStreamTexture::get_recognized_extensions(List<String> *p_extensions) const {
 
 	p_extensions->push_back("stex");
 }
-bool ResourceFormatLoaderStreamTexture::handles_type(const String& p_type) const{
-	return p_type=="StreamTexture";
-
+bool ResourceFormatLoaderStreamTexture::handles_type(const String &p_type) const {
+	return p_type == "StreamTexture";
 }
-String ResourceFormatLoaderStreamTexture::get_resource_type(const String &p_path) const{
+String ResourceFormatLoaderStreamTexture::get_resource_type(const String &p_path) const {
 
-	if (p_path.get_extension().to_lower()=="stex")
+	if (p_path.get_extension().to_lower() == "stex")
 		return "StreamTexture";
 	return "";
 }
 
-
-
-
-
 //////////////////////////////////////////
 
-
 int AtlasTexture::get_width() const {
 
-	if (region.size.width==0) {
+	if (region.size.width == 0) {
 		if (atlas.is_valid())
 			return atlas->get_width();
 		return 1;
 	} else {
-		return region.size.width+margin.size.width;
+		return region.size.width + margin.size.width;
 	}
 }
 int AtlasTexture::get_height() const {
 
-	if (region.size.height==0) {
+	if (region.size.height == 0) {
 		if (atlas.is_valid())
 			return atlas->get_height();
 		return 1;
 	} else {
-		return region.size.height+margin.size.height;
+		return region.size.height + margin.size.height;
 	}
 }
 RID AtlasTexture::get_rid() const {
@@ -881,11 +815,9 @@ void AtlasTexture::set_flags(uint32_t p_flags) {
 
 	if (atlas.is_valid())
 		atlas->set_flags(p_flags);
-
 }
 
-
-uint32_t AtlasTexture::get_flags() const{
+uint32_t AtlasTexture::get_flags() const {
 
 	if (atlas.is_valid())
 		return atlas->get_flags();
@@ -893,24 +825,23 @@ uint32_t AtlasTexture::get_flags() const{
 	return 0;
 }
 
-void AtlasTexture::set_atlas(const Ref<Texture>& p_atlas){
+void AtlasTexture::set_atlas(const Ref<Texture> &p_atlas) {
 
-	if (atlas==p_atlas)
+	if (atlas == p_atlas)
 		return;
-	atlas=p_atlas;
+	atlas = p_atlas;
 	emit_changed();
 	emit_signal("atlas_changed");
 }
-Ref<Texture> AtlasTexture::get_atlas() const{
+Ref<Texture> AtlasTexture::get_atlas() const {
 
 	return atlas;
 }
 
-void AtlasTexture::set_region(const Rect2& p_region) {
+void AtlasTexture::set_region(const Rect2 &p_region) {
 
-	region=p_region;
+	region = p_region;
 	emit_changed();
-
 }
 
 Rect2 AtlasTexture::get_region() const {
@@ -918,11 +849,10 @@ Rect2 AtlasTexture::get_region() const {
 	return region;
 }
 
-void AtlasTexture::set_margin(const Rect2& p_margin) {
+void AtlasTexture::set_margin(const Rect2 &p_margin) {
 
-	margin=p_margin;
+	margin = p_margin;
 	emit_changed();
-
 }
 
 Rect2 AtlasTexture::get_margin() const {
@@ -932,144 +862,128 @@ Rect2 AtlasTexture::get_margin() const {
 
 void AtlasTexture::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_atlas","atlas:Texture"),&AtlasTexture::set_atlas);
-	ClassDB::bind_method(D_METHOD("get_atlas:Texture"),&AtlasTexture::get_atlas);
+	ClassDB::bind_method(D_METHOD("set_atlas", "atlas:Texture"), &AtlasTexture::set_atlas);
+	ClassDB::bind_method(D_METHOD("get_atlas:Texture"), &AtlasTexture::get_atlas);
 
-	ClassDB::bind_method(D_METHOD("set_region","region"),&AtlasTexture::set_region);
-	ClassDB::bind_method(D_METHOD("get_region"),&AtlasTexture::get_region);
+	ClassDB::bind_method(D_METHOD("set_region", "region"), &AtlasTexture::set_region);
+	ClassDB::bind_method(D_METHOD("get_region"), &AtlasTexture::get_region);
 
-	ClassDB::bind_method(D_METHOD("set_margin","margin"),&AtlasTexture::set_margin);
-	ClassDB::bind_method(D_METHOD("get_margin"),&AtlasTexture::get_margin);
+	ClassDB::bind_method(D_METHOD("set_margin", "margin"), &AtlasTexture::set_margin);
+	ClassDB::bind_method(D_METHOD("get_margin"), &AtlasTexture::get_margin);
 
 	ADD_SIGNAL(MethodInfo("atlas_changed"));
 
-	ADD_PROPERTY( PropertyInfo( Variant::OBJECT, "atlas", PROPERTY_HINT_RESOURCE_TYPE,"Texture"), "set_atlas","get_atlas") ;
-	ADD_PROPERTY( PropertyInfo( Variant::RECT2, "region"), "set_region","get_region") ;
-	ADD_PROPERTY( PropertyInfo( Variant::RECT2, "margin"), "set_margin","get_margin") ;
-
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "atlas", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_atlas", "get_atlas");
+	ADD_PROPERTY(PropertyInfo(Variant::RECT2, "region"), "set_region", "get_region");
+	ADD_PROPERTY(PropertyInfo(Variant::RECT2, "margin"), "set_margin", "get_margin");
 }
 
+void AtlasTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
 
-
-
-void AtlasTexture::draw(RID p_canvas_item, const Point2& p_pos, const Color& p_modulate, bool p_transpose) const {
-
-	Rect2 rc=region;
+	Rect2 rc = region;
 
 	if (!atlas.is_valid())
 		return;
 
-	if (rc.size.width==0) {
-		rc.size.width=atlas->get_width();
+	if (rc.size.width == 0) {
+		rc.size.width = atlas->get_width();
 	}
 
-	if (rc.size.height==0) {
-		rc.size.height=atlas->get_height();
+	if (rc.size.height == 0) {
+		rc.size.height = atlas->get_height();
 	}
 
-	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item,Rect2(p_pos+margin.pos,rc.size),atlas->get_rid(),rc,p_modulate,p_transpose);
+	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, Rect2(p_pos + margin.pos, rc.size), atlas->get_rid(), rc, p_modulate, p_transpose);
 }
 
-void AtlasTexture::draw_rect(RID p_canvas_item,const Rect2& p_rect, bool p_tile,const Color& p_modulate, bool p_transpose) const {
+void AtlasTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
 
-	Rect2 rc=region;
+	Rect2 rc = region;
 
 	if (!atlas.is_valid())
 		return;
 
-	if (rc.size.width==0) {
-		rc.size.width=atlas->get_width();
+	if (rc.size.width == 0) {
+		rc.size.width = atlas->get_width();
 	}
 
-	if (rc.size.height==0) {
-		rc.size.height=atlas->get_height();
+	if (rc.size.height == 0) {
+		rc.size.height = atlas->get_height();
 	}
 
-	Vector2 scale = p_rect.size / (region.size+margin.size);
-	Rect2 dr( p_rect.pos+margin.pos*scale,rc.size*scale  );
-
-	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item,dr,atlas->get_rid(),rc,p_modulate,p_transpose);
+	Vector2 scale = p_rect.size / (region.size + margin.size);
+	Rect2 dr(p_rect.pos + margin.pos * scale, rc.size * scale);
 
+	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, dr, atlas->get_rid(), rc, p_modulate, p_transpose);
 }
-void AtlasTexture::draw_rect_region(RID p_canvas_item,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate, bool p_transpose) const {
+void AtlasTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
 
 	//this might not necesarily work well if using a rect, needs to be fixed properly
-	Rect2 rc=region;
+	Rect2 rc = region;
 
 	if (!atlas.is_valid())
 		return;
 
-	Rect2 src=p_src_rect;
-	src.pos+=(rc.pos-margin.pos);
+	Rect2 src = p_src_rect;
+	src.pos += (rc.pos - margin.pos);
 	Rect2 src_c = rc.clip(src);
-	if (src_c.size==Size2())
+	if (src_c.size == Size2())
 		return;
-	Vector2 ofs = (src_c.pos-src.pos);
+	Vector2 ofs = (src_c.pos - src.pos);
 
 	Vector2 scale = p_rect.size / p_src_rect.size;
-    if(scale.x < 0)
-    {
-        float mx = (margin.size.width - margin.pos.x);
-        mx -= margin.pos.x;
-        ofs.x = -(ofs.x + mx);
-    }
-    if(scale.y < 0)
-    {
-        float my = margin.size.height - margin.pos.y;
-        my -= margin.pos.y;
-        ofs.y = -(ofs.y + my);
-    }
-	Rect2 dr( p_rect.pos+ofs*scale,src_c.size*scale );
+	if (scale.x < 0) {
+		float mx = (margin.size.width - margin.pos.x);
+		mx -= margin.pos.x;
+		ofs.x = -(ofs.x + mx);
+	}
+	if (scale.y < 0) {
+		float my = margin.size.height - margin.pos.y;
+		my -= margin.pos.y;
+		ofs.y = -(ofs.y + my);
+	}
+	Rect2 dr(p_rect.pos + ofs * scale, src_c.size * scale);
 
-	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item,dr,atlas->get_rid(),src_c,p_modulate,p_transpose);
+	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, dr, atlas->get_rid(), src_c, p_modulate, p_transpose);
 }
 
-bool AtlasTexture::get_rect_region(const Rect2& p_rect, const Rect2& p_src_rect,Rect2& r_rect,Rect2& r_src_rect) const {
+bool AtlasTexture::get_rect_region(const Rect2 &p_rect, const Rect2 &p_src_rect, Rect2 &r_rect, Rect2 &r_src_rect) const {
 
-	Rect2 rc=region;
+	Rect2 rc = region;
 
 	if (!atlas.is_valid())
 		return false;
 
-	Rect2 src=p_src_rect;
-	src.pos+=(rc.pos-margin.pos);
+	Rect2 src = p_src_rect;
+	src.pos += (rc.pos - margin.pos);
 	Rect2 src_c = rc.clip(src);
-	if (src_c.size==Size2())
+	if (src_c.size == Size2())
 		return false;
-	Vector2 ofs = (src_c.pos-src.pos);
+	Vector2 ofs = (src_c.pos - src.pos);
 
 	Vector2 scale = p_rect.size / p_src_rect.size;
-    if(scale.x < 0)
-    {
-	float mx = (margin.size.width - margin.pos.x);
-	mx -= margin.pos.x;
-	ofs.x = -(ofs.x + mx);
-    }
-    if(scale.y < 0)
-    {
-	float my = margin.size.height - margin.pos.y;
-	my -= margin.pos.y;
-	ofs.y = -(ofs.y + my);
-    }
-	Rect2 dr( p_rect.pos+ofs*scale,src_c.size*scale );
-
-
-
-	r_rect=dr;
-	r_src_rect=src_c;
+	if (scale.x < 0) {
+		float mx = (margin.size.width - margin.pos.x);
+		mx -= margin.pos.x;
+		ofs.x = -(ofs.x + mx);
+	}
+	if (scale.y < 0) {
+		float my = margin.size.height - margin.pos.y;
+		my -= margin.pos.y;
+		ofs.y = -(ofs.y + my);
+	}
+	Rect2 dr(p_rect.pos + ofs * scale, src_c.size * scale);
+
+	r_rect = dr;
+	r_src_rect = src_c;
 	return true;
 }
 
-
 AtlasTexture::AtlasTexture() {
-
-
 }
 
-
 //////////////////////////////////////////
 
-
 int LargeTexture::get_width() const {
 
 	return size.width;
@@ -1085,7 +999,7 @@ RID LargeTexture::get_rid() const {
 
 bool LargeTexture::has_alpha() const {
 
-	for(int i=0;i<pieces.size();i++) {
+	for (int i = 0; i < pieces.size(); i++) {
 		if (pieces[i].texture->has_alpha())
 			return true;
 	}
@@ -1095,14 +1009,12 @@ bool LargeTexture::has_alpha() const {
 
 void LargeTexture::set_flags(uint32_t p_flags) {
 
-	for(int i=0;i<pieces.size();i++) {
+	for (int i = 0; i < pieces.size(); i++) {
 		pieces[i].texture->set_flags(p_flags);
 	}
-
 }
 
-
-uint32_t LargeTexture::get_flags() const{
+uint32_t LargeTexture::get_flags() const {
 
 	if (pieces.size())
 		return pieces[0].texture->get_flags();
@@ -1110,168 +1022,149 @@ uint32_t LargeTexture::get_flags() const{
 	return 0;
 }
 
-
-int LargeTexture::add_piece(const Point2& p_offset,const Ref<Texture>& p_texture) {
+int LargeTexture::add_piece(const Point2 &p_offset, const Ref<Texture> &p_texture) {
 
 	ERR_FAIL_COND_V(p_texture.is_null(), -1);
 	Piece p;
-	p.offset=p_offset;
-	p.texture=p_texture;
+	p.offset = p_offset;
+	p.texture = p_texture;
 	pieces.push_back(p);
 
 	return pieces.size() - 1;
 }
 
-void LargeTexture::set_piece_offset(int p_idx, const Point2& p_offset) {
+void LargeTexture::set_piece_offset(int p_idx, const Point2 &p_offset) {
 
 	ERR_FAIL_INDEX(p_idx, pieces.size());
 	pieces[p_idx].offset = p_offset;
 };
 
-void LargeTexture::set_piece_texture(int p_idx, const Ref<Texture>& p_texture) {
+void LargeTexture::set_piece_texture(int p_idx, const Ref<Texture> &p_texture) {
 
 	ERR_FAIL_INDEX(p_idx, pieces.size());
 	pieces[p_idx].texture = p_texture;
 };
 
+void LargeTexture::set_size(const Size2 &p_size) {
 
-
-void LargeTexture::set_size(const Size2& p_size){
-
-	size=p_size;
+	size = p_size;
 }
-void LargeTexture::clear(){
+void LargeTexture::clear() {
 
 	pieces.clear();
-	size=Size2i();
+	size = Size2i();
 }
 
 Array LargeTexture::_get_data() const {
 
 	Array arr;
-	for(int i=0;i<pieces.size();i++) {
+	for (int i = 0; i < pieces.size(); i++) {
 		arr.push_back(pieces[i].offset);
 		arr.push_back(pieces[i].texture);
 	}
 	arr.push_back(Size2(size));
 	return arr;
-
 }
-void LargeTexture::_set_data(const Array& p_array) {
+void LargeTexture::_set_data(const Array &p_array) {
 
-	ERR_FAIL_COND(p_array.size()<1);
-	ERR_FAIL_COND(!(p_array.size()&1));
+	ERR_FAIL_COND(p_array.size() < 1);
+	ERR_FAIL_COND(!(p_array.size() & 1));
 	clear();
-	for(int i=0;i<p_array.size()-1;i+=2) {
-		add_piece(p_array[i],p_array[i+1]);
+	for (int i = 0; i < p_array.size() - 1; i += 2) {
+		add_piece(p_array[i], p_array[i + 1]);
 	}
-	size=Size2(p_array[p_array.size()-1]);
+	size = Size2(p_array[p_array.size() - 1]);
 }
 
 int LargeTexture::get_piece_count() const {
 
 	return pieces.size();
 }
-Vector2 LargeTexture::get_piece_offset(int p_idx) const{
+Vector2 LargeTexture::get_piece_offset(int p_idx) const {
 
-	ERR_FAIL_INDEX_V(p_idx,pieces.size(),Vector2());
+	ERR_FAIL_INDEX_V(p_idx, pieces.size(), Vector2());
 	return pieces[p_idx].offset;
 }
-Ref<Texture> LargeTexture::get_piece_texture(int p_idx) const{
+Ref<Texture> LargeTexture::get_piece_texture(int p_idx) const {
 
-	ERR_FAIL_INDEX_V(p_idx,pieces.size(),Ref<Texture>());
+	ERR_FAIL_INDEX_V(p_idx, pieces.size(), Ref<Texture>());
 	return pieces[p_idx].texture;
-
 }
 
-
 void LargeTexture::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("add_piece","ofs","texture:Texture"),&LargeTexture::add_piece);
-	ClassDB::bind_method(D_METHOD("set_piece_offset", "idx", "ofs"),&LargeTexture::set_piece_offset);
-	ClassDB::bind_method(D_METHOD("set_piece_texture","idx", "texture:Texture"),&LargeTexture::set_piece_texture);
-	ClassDB::bind_method(D_METHOD("set_size","size"),&LargeTexture::set_size);
-	ClassDB::bind_method(D_METHOD("clear"),&LargeTexture::clear);
+	ClassDB::bind_method(D_METHOD("add_piece", "ofs", "texture:Texture"), &LargeTexture::add_piece);
+	ClassDB::bind_method(D_METHOD("set_piece_offset", "idx", "ofs"), &LargeTexture::set_piece_offset);
+	ClassDB::bind_method(D_METHOD("set_piece_texture", "idx", "texture:Texture"), &LargeTexture::set_piece_texture);
+	ClassDB::bind_method(D_METHOD("set_size", "size"), &LargeTexture::set_size);
+	ClassDB::bind_method(D_METHOD("clear"), &LargeTexture::clear);
 
-	ClassDB::bind_method(D_METHOD("get_piece_count"),&LargeTexture::get_piece_count);
-	ClassDB::bind_method(D_METHOD("get_piece_offset","idx"),&LargeTexture::get_piece_offset);
-	ClassDB::bind_method(D_METHOD("get_piece_texture:Texture","idx"),&LargeTexture::get_piece_texture);
+	ClassDB::bind_method(D_METHOD("get_piece_count"), &LargeTexture::get_piece_count);
+	ClassDB::bind_method(D_METHOD("get_piece_offset", "idx"), &LargeTexture::get_piece_offset);
+	ClassDB::bind_method(D_METHOD("get_piece_texture:Texture", "idx"), &LargeTexture::get_piece_texture);
 
-	ClassDB::bind_method(D_METHOD("_set_data","data"),&LargeTexture::_set_data);
-	ClassDB::bind_method(D_METHOD("_get_data"),&LargeTexture::_get_data);
-
-	ADD_PROPERTY( PropertyInfo( Variant::ARRAY, "_data",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR), "_set_data","_get_data") ;
+	ClassDB::bind_method(D_METHOD("_set_data", "data"), &LargeTexture::_set_data);
+	ClassDB::bind_method(D_METHOD("_get_data"), &LargeTexture::_get_data);
 
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_data", "_get_data");
 }
 
+void LargeTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
 
-
-
-void LargeTexture::draw(RID p_canvas_item, const Point2& p_pos, const Color& p_modulate, bool p_transpose) const {
-
-	for(int i=0;i<pieces.size();i++) {
+	for (int i = 0; i < pieces.size(); i++) {
 
 		// TODO
-		pieces[i].texture->draw(p_canvas_item,pieces[i].offset+p_pos,p_modulate,p_transpose);
+		pieces[i].texture->draw(p_canvas_item, pieces[i].offset + p_pos, p_modulate, p_transpose);
 	}
 }
 
-void LargeTexture::draw_rect(RID p_canvas_item,const Rect2& p_rect, bool p_tile,const Color& p_modulate, bool p_transpose) const {
+void LargeTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
 
 	//tiling not supported for this
-	if (size.x==0 || size.y==0)
+	if (size.x == 0 || size.y == 0)
 		return;
 
-	Size2 scale = p_rect.size/size;
+	Size2 scale = p_rect.size / size;
 
-	for(int i=0;i<pieces.size();i++) {
+	for (int i = 0; i < pieces.size(); i++) {
 
 		// TODO
-		pieces[i].texture->draw_rect(p_canvas_item,Rect2(pieces[i].offset*scale+p_rect.pos,pieces[i].texture->get_size()*scale),false,p_modulate,p_transpose);
+		pieces[i].texture->draw_rect(p_canvas_item, Rect2(pieces[i].offset * scale + p_rect.pos, pieces[i].texture->get_size() * scale), false, p_modulate, p_transpose);
 	}
 }
-void LargeTexture::draw_rect_region(RID p_canvas_item,const Rect2& p_rect, const Rect2& p_src_rect,const Color& p_modulate, bool p_transpose) const {
-
+void LargeTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
 
 	//tiling not supported for this
-	if (p_src_rect.size.x==0 || p_src_rect.size.y==0)
+	if (p_src_rect.size.x == 0 || p_src_rect.size.y == 0)
 		return;
 
-	Size2 scale = p_rect.size/p_src_rect.size;
+	Size2 scale = p_rect.size / p_src_rect.size;
 
-	for(int i=0;i<pieces.size();i++) {
+	for (int i = 0; i < pieces.size(); i++) {
 
 		// TODO
-		Rect2 rect( pieces[i].offset, pieces[i].texture->get_size());
+		Rect2 rect(pieces[i].offset, pieces[i].texture->get_size());
 		if (!p_src_rect.intersects(rect))
 			continue;
 		Rect2 local = p_src_rect.clip(rect);
 		Rect2 target = local;
-		target.size*=scale;
-		target.pos=p_rect.pos+(p_src_rect.pos+rect.pos)*scale;
-		local.pos-=rect.pos;
-		pieces[i].texture->draw_rect_region(p_canvas_item,target,local,p_modulate,p_transpose);
+		target.size *= scale;
+		target.pos = p_rect.pos + (p_src_rect.pos + rect.pos) * scale;
+		local.pos -= rect.pos;
+		pieces[i].texture->draw_rect_region(p_canvas_item, target, local, p_modulate, p_transpose);
 	}
-
 }
 
-
 LargeTexture::LargeTexture() {
-
-
 }
 
-
 ///////////////////////////////////////////////
 
-
-
-
 void CubeMap::set_flags(uint32_t p_flags) {
 
-	flags=p_flags;
+	flags = p_flags;
 	if (_is_valid())
-		VS::get_singleton()->texture_set_flags(cubemap,flags|VS::TEXTURE_FLAG_CUBEMAP);
+		VS::get_singleton()->texture_set_flags(cubemap, flags | VS::TEXTURE_FLAG_CUBEMAP);
 }
 
 uint32_t CubeMap::get_flags() const {
@@ -1279,27 +1172,26 @@ uint32_t CubeMap::get_flags() const {
 	return flags;
 }
 
-void CubeMap::set_side(Side p_side,const Image& p_image) {
+void CubeMap::set_side(Side p_side, const Image &p_image) {
 
 	ERR_FAIL_COND(p_image.empty());
-	ERR_FAIL_INDEX(p_side,6);
+	ERR_FAIL_INDEX(p_side, 6);
 	if (!_is_valid()) {
 		format = p_image.get_format();
-		w=p_image.get_width();
-		h=p_image.get_height();
-		VS::get_singleton()->texture_allocate(cubemap,w,h,p_image.get_format(),flags|VS::TEXTURE_FLAG_CUBEMAP);
+		w = p_image.get_width();
+		h = p_image.get_height();
+		VS::get_singleton()->texture_allocate(cubemap, w, h, p_image.get_format(), flags | VS::TEXTURE_FLAG_CUBEMAP);
 	}
 
-	VS::get_singleton()->texture_set_data(cubemap,p_image,VS::CubeMapSide(p_side));
-	valid[p_side]=true;
+	VS::get_singleton()->texture_set_data(cubemap, p_image, VS::CubeMapSide(p_side));
+	valid[p_side] = true;
 }
 
 Image CubeMap::get_side(Side p_side) const {
 
 	if (!valid[p_side])
 		return Image();
-	return VS::get_singleton()->texture_get_data(cubemap,VS::CubeMapSide(p_side));
-
+	return VS::get_singleton()->texture_get_data(cubemap, VS::CubeMapSide(p_side));
 }
 
 Image::Format CubeMap::get_format() const {
@@ -1320,10 +1212,9 @@ RID CubeMap::get_rid() const {
 	return cubemap;
 }
 
-
 void CubeMap::set_storage(Storage p_storage) {
 
-	storage=p_storage;
+	storage = p_storage;
 }
 
 CubeMap::Storage CubeMap::get_storage() const {
@@ -1333,7 +1224,7 @@ CubeMap::Storage CubeMap::get_storage() const {
 
 void CubeMap::set_lossy_storage_quality(float p_lossy_storage_quality) {
 
-	lossy_storage_quality=p_lossy_storage_quality;
+	lossy_storage_quality = p_lossy_storage_quality;
 }
 
 float CubeMap::get_lossy_storage_quality() const {
@@ -1341,149 +1232,133 @@ float CubeMap::get_lossy_storage_quality() const {
 	return lossy_storage_quality;
 }
 
-void CubeMap::set_path(const String& p_path,bool p_take_over) {
+void CubeMap::set_path(const String &p_path, bool p_take_over) {
 
 	if (cubemap.is_valid()) {
-		VisualServer::get_singleton()->texture_set_path(cubemap,p_path);
+		VisualServer::get_singleton()->texture_set_path(cubemap, p_path);
 	}
 
-	Resource::set_path(p_path,p_take_over);
+	Resource::set_path(p_path, p_take_over);
 }
 
+bool CubeMap::_set(const StringName &p_name, const Variant &p_value) {
 
-bool CubeMap::_set(const StringName& p_name, const Variant& p_value) {
-
-	if (p_name=="side/left") {
-		set_side(SIDE_LEFT,p_value);
-	} else if (p_name=="side/right") {
-		set_side(SIDE_RIGHT,p_value);
-	} else if (p_name=="side/bottom") {
-		set_side(SIDE_BOTTOM,p_value);
-	} else if (p_name=="side/top") {
-		set_side(SIDE_TOP,p_value);
-	} else if (p_name=="side/front") {
-		set_side(SIDE_FRONT,p_value);
-	} else if (p_name=="side/back") {
-		set_side(SIDE_BACK,p_value);
-	} else if (p_name=="flags") {
+	if (p_name == "side/left") {
+		set_side(SIDE_LEFT, p_value);
+	} else if (p_name == "side/right") {
+		set_side(SIDE_RIGHT, p_value);
+	} else if (p_name == "side/bottom") {
+		set_side(SIDE_BOTTOM, p_value);
+	} else if (p_name == "side/top") {
+		set_side(SIDE_TOP, p_value);
+	} else if (p_name == "side/front") {
+		set_side(SIDE_FRONT, p_value);
+	} else if (p_name == "side/back") {
+		set_side(SIDE_BACK, p_value);
+	} else if (p_name == "flags") {
 		set_flags(p_value);
-	} else if (p_name=="storage") {
-		storage=Storage(p_value.operator int());
-	} else if (p_name=="lossy_quality") {
-		lossy_storage_quality=p_value;
+	} else if (p_name == "storage") {
+		storage = Storage(p_value.operator int());
+	} else if (p_name == "lossy_quality") {
+		lossy_storage_quality = p_value;
 	} else
 		return false;
 
 	return true;
-
 }
 
-bool CubeMap::_get(const StringName& p_name,Variant &r_ret) const {
-
-	if (p_name=="side/left") {
-		r_ret=get_side(SIDE_LEFT);
-	} else if (p_name=="side/right") {
-		r_ret=get_side(SIDE_RIGHT);
-	} else if (p_name=="side/bottom") {
-		r_ret=get_side(SIDE_BOTTOM);
-	} else if (p_name=="side/top") {
-		r_ret=get_side(SIDE_TOP);
-	} else if (p_name=="side/front") {
-		r_ret=get_side(SIDE_FRONT);
-	} else if (p_name=="side/back") {
-		r_ret=get_side(SIDE_BACK);
-	} else if (p_name=="flags") {
-		r_ret= flags;
-	} else if (p_name=="storage") {
-		r_ret= storage;
-	} else if (p_name=="lossy_quality") {
-		r_ret= lossy_storage_quality;
+bool CubeMap::_get(const StringName &p_name, Variant &r_ret) const {
+
+	if (p_name == "side/left") {
+		r_ret = get_side(SIDE_LEFT);
+	} else if (p_name == "side/right") {
+		r_ret = get_side(SIDE_RIGHT);
+	} else if (p_name == "side/bottom") {
+		r_ret = get_side(SIDE_BOTTOM);
+	} else if (p_name == "side/top") {
+		r_ret = get_side(SIDE_TOP);
+	} else if (p_name == "side/front") {
+		r_ret = get_side(SIDE_FRONT);
+	} else if (p_name == "side/back") {
+		r_ret = get_side(SIDE_BACK);
+	} else if (p_name == "flags") {
+		r_ret = flags;
+	} else if (p_name == "storage") {
+		r_ret = storage;
+	} else if (p_name == "lossy_quality") {
+		r_ret = lossy_storage_quality;
 	} else
 		return false;
 
 	return true;
 }
 
+void CubeMap::_get_property_list(List<PropertyInfo> *p_list) const {
 
-
-
-void CubeMap::_get_property_list( List<PropertyInfo> *p_list) const {
-
-
-	PropertyHint img_hint=PROPERTY_HINT_NONE;
-	if (storage==STORAGE_COMPRESS_LOSSY) {
-		img_hint=PROPERTY_HINT_IMAGE_COMPRESS_LOSSY;
-	} else if (storage==STORAGE_COMPRESS_LOSSLESS) {
-		img_hint=PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS;
+	PropertyHint img_hint = PROPERTY_HINT_NONE;
+	if (storage == STORAGE_COMPRESS_LOSSY) {
+		img_hint = PROPERTY_HINT_IMAGE_COMPRESS_LOSSY;
+	} else if (storage == STORAGE_COMPRESS_LOSSLESS) {
+		img_hint = PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS;
 	}
 
-
-	p_list->push_back( PropertyInfo( Variant::INT, "flags", PROPERTY_HINT_FLAGS,"Mipmaps,Repeat,Filter" ) );
-	p_list->push_back( PropertyInfo( Variant::IMAGE, "side/left", img_hint,String::num(lossy_storage_quality)) );
-	p_list->push_back( PropertyInfo( Variant::IMAGE, "side/right", img_hint,String::num(lossy_storage_quality)) );
-	p_list->push_back( PropertyInfo( Variant::IMAGE, "side/bottom", img_hint,String::num(lossy_storage_quality)) );
-	p_list->push_back( PropertyInfo( Variant::IMAGE, "side/top", img_hint,String::num(lossy_storage_quality)) );
-	p_list->push_back( PropertyInfo( Variant::IMAGE, "side/front", img_hint,String::num(lossy_storage_quality)) );
-	p_list->push_back( PropertyInfo( Variant::IMAGE, "side/back", img_hint,String::num(lossy_storage_quality)) );
-	p_list->push_back( PropertyInfo( Variant::INT, "storage", PROPERTY_HINT_ENUM,"Uncompressed,Compress Lossy,Compress Lossless",PROPERTY_USAGE_EDITOR));
-	p_list->push_back( PropertyInfo( Variant::REAL, "lossy_quality", PROPERTY_HINT_RANGE,"0.0,1.0,0.01" ) );
+	p_list->push_back(PropertyInfo(Variant::INT, "flags", PROPERTY_HINT_FLAGS, "Mipmaps,Repeat,Filter"));
+	p_list->push_back(PropertyInfo(Variant::IMAGE, "side/left", img_hint, String::num(lossy_storage_quality)));
+	p_list->push_back(PropertyInfo(Variant::IMAGE, "side/right", img_hint, String::num(lossy_storage_quality)));
+	p_list->push_back(PropertyInfo(Variant::IMAGE, "side/bottom", img_hint, String::num(lossy_storage_quality)));
+	p_list->push_back(PropertyInfo(Variant::IMAGE, "side/top", img_hint, String::num(lossy_storage_quality)));
+	p_list->push_back(PropertyInfo(Variant::IMAGE, "side/front", img_hint, String::num(lossy_storage_quality)));
+	p_list->push_back(PropertyInfo(Variant::IMAGE, "side/back", img_hint, String::num(lossy_storage_quality)));
+	p_list->push_back(PropertyInfo(Variant::INT, "storage", PROPERTY_HINT_ENUM, "Uncompressed,Compress Lossy,Compress Lossless", PROPERTY_USAGE_EDITOR));
+	p_list->push_back(PropertyInfo(Variant::REAL, "lossy_quality", PROPERTY_HINT_RANGE, "0.0,1.0,0.01"));
 }
 
 void CubeMap::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("get_width"),&CubeMap::get_width);
-	ClassDB::bind_method(D_METHOD("get_height"),&CubeMap::get_height);
+	ClassDB::bind_method(D_METHOD("get_width"), &CubeMap::get_width);
+	ClassDB::bind_method(D_METHOD("get_height"), &CubeMap::get_height);
 	//ClassDB::bind_method(D_METHOD("get_rid"),&CubeMap::get_rid);
-	ClassDB::bind_method(D_METHOD("set_flags","flags"),&CubeMap::set_flags);
-	ClassDB::bind_method(D_METHOD("get_flags"),&CubeMap::get_flags);
-
-	ClassDB::bind_method(D_METHOD("set_side","side","image"),&CubeMap::set_side);
-	ClassDB::bind_method(D_METHOD("get_side","side"),&CubeMap::get_side);
-	ClassDB::bind_method(D_METHOD("set_storage","mode"),&CubeMap::set_storage);
-	ClassDB::bind_method(D_METHOD("get_storage"),&CubeMap::get_storage);
-	ClassDB::bind_method(D_METHOD("set_lossy_storage_quality","quality"),&CubeMap::set_lossy_storage_quality);
-	ClassDB::bind_method(D_METHOD("get_lossy_storage_quality"),&CubeMap::get_lossy_storage_quality);
-
-
-	BIND_CONSTANT( STORAGE_RAW );
-	BIND_CONSTANT( STORAGE_COMPRESS_LOSSY  );
-	BIND_CONSTANT( STORAGE_COMPRESS_LOSSLESS );
-	BIND_CONSTANT( SIDE_LEFT );
-	BIND_CONSTANT( SIDE_RIGHT );
-	BIND_CONSTANT( SIDE_BOTTOM );
-	BIND_CONSTANT( SIDE_TOP );
-	BIND_CONSTANT( SIDE_FRONT );
-	BIND_CONSTANT( SIDE_BACK );
-	BIND_CONSTANT( FLAG_MIPMAPS );
-	BIND_CONSTANT( FLAG_REPEAT );
-	BIND_CONSTANT( FLAG_FILTER );
-	BIND_CONSTANT( FLAGS_DEFAULT );
-
-
+	ClassDB::bind_method(D_METHOD("set_flags", "flags"), &CubeMap::set_flags);
+	ClassDB::bind_method(D_METHOD("get_flags"), &CubeMap::get_flags);
+
+	ClassDB::bind_method(D_METHOD("set_side", "side", "image"), &CubeMap::set_side);
+	ClassDB::bind_method(D_METHOD("get_side", "side"), &CubeMap::get_side);
+	ClassDB::bind_method(D_METHOD("set_storage", "mode"), &CubeMap::set_storage);
+	ClassDB::bind_method(D_METHOD("get_storage"), &CubeMap::get_storage);
+	ClassDB::bind_method(D_METHOD("set_lossy_storage_quality", "quality"), &CubeMap::set_lossy_storage_quality);
+	ClassDB::bind_method(D_METHOD("get_lossy_storage_quality"), &CubeMap::get_lossy_storage_quality);
+
+	BIND_CONSTANT(STORAGE_RAW);
+	BIND_CONSTANT(STORAGE_COMPRESS_LOSSY);
+	BIND_CONSTANT(STORAGE_COMPRESS_LOSSLESS);
+	BIND_CONSTANT(SIDE_LEFT);
+	BIND_CONSTANT(SIDE_RIGHT);
+	BIND_CONSTANT(SIDE_BOTTOM);
+	BIND_CONSTANT(SIDE_TOP);
+	BIND_CONSTANT(SIDE_FRONT);
+	BIND_CONSTANT(SIDE_BACK);
+	BIND_CONSTANT(FLAG_MIPMAPS);
+	BIND_CONSTANT(FLAG_REPEAT);
+	BIND_CONSTANT(FLAG_FILTER);
+	BIND_CONSTANT(FLAGS_DEFAULT);
 }
 
 CubeMap::CubeMap() {
 
-	w=h=0;
-	flags=FLAGS_DEFAULT;
-	for(int i=0;i<6;i++)
-		valid[i]=false;
+	w = h = 0;
+	flags = FLAGS_DEFAULT;
+	for (int i = 0; i < 6; i++)
+		valid[i] = false;
 	cubemap = VisualServer::get_singleton()->texture_create();
 	storage = STORAGE_RAW;
-	lossy_storage_quality=0.7;
-
-
+	lossy_storage_quality = 0.7;
 }
 
-
 CubeMap::~CubeMap() {
 
-	VisualServer::get_singleton()->free( cubemap );
+	VisualServer::get_singleton()->free(cubemap);
 }
 
-
-
-
 /*	BIND_CONSTANT( FLAG_CUBEMAP );
 	BIND_CONSTANT( CUBEMAP_LEFT );
 	BIND_CONSTANT( CUBEMAP_RIGHT );