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, 528 insertions, 582 deletions

diff --git a/scene/resources/material.cpp b/scene/resources/material.cpp
index 3780c466a5..410f4962fa 100644
--- a/scene/resources/material.cpp
+++ b/scene/resources/material.cpp
@@ -36,7 +36,7 @@ RID Material::get_rid() const {
 
 Material::Material() {
 
-	material=VisualServer::get_singleton()->material_create();
+	material = VisualServer::get_singleton()->material_create();
 }
 
 Material::~Material() {
@@ -44,13 +44,12 @@ Material::~Material() {
 	VisualServer::get_singleton()->free(material);
 }
 
-
 /////////////////////////////////
 
-Mutex *FixedSpatialMaterial::material_mutex=NULL;
+Mutex *FixedSpatialMaterial::material_mutex = NULL;
 SelfList<FixedSpatialMaterial>::List FixedSpatialMaterial::dirty_materials;
-Map<FixedSpatialMaterial::MaterialKey,FixedSpatialMaterial::ShaderData> FixedSpatialMaterial::shader_map;
-FixedSpatialMaterial::ShaderNames* FixedSpatialMaterial::shader_names=NULL;
+Map<FixedSpatialMaterial::MaterialKey, FixedSpatialMaterial::ShaderData> FixedSpatialMaterial::shader_map;
+FixedSpatialMaterial::ShaderNames *FixedSpatialMaterial::shader_names = NULL;
 
 void FixedSpatialMaterial::init_shaders() {
 
@@ -58,303 +57,293 @@ void FixedSpatialMaterial::init_shaders() {
 	material_mutex = Mutex::create();
 #endif
 
-	shader_names = memnew( ShaderNames );
-
-	shader_names->albedo="albedo";
-	shader_names->specular="specular";
-	shader_names->roughness="roughness";
-	shader_names->metalness="metalness";
-	shader_names->emission="emission";
-	shader_names->emission_energy="emission_energy";
-	shader_names->normal_scale="normal_scale";
-	shader_names->rim="rim";
-	shader_names->rim_tint="rim_tint";
-	shader_names->clearcoat="clearcoat";
-	shader_names->clearcoat_gloss="clearcoat_gloss";
-	shader_names->anisotropy="anisotropy_ratio";
-	shader_names->height_scale="height_scale";
-	shader_names->subsurface_scattering_strength="subsurface_scattering_strength";
-	shader_names->refraction="refraction";
-	shader_names->refraction_roughness="refraction_roughness";
-	shader_names->point_size="point_size";
-	shader_names->uv1_scale="uv1_scale";
-	shader_names->uv1_offset="uv1_offset";
-	shader_names->uv2_scale="uv2_scale";
-	shader_names->uv2_offset="uv2_offset";
-
-	shader_names->texture_names[TEXTURE_ALBEDO]="texture_albedo";
-	shader_names->texture_names[TEXTURE_SPECULAR]="texture_specular";
-	shader_names->texture_names[TEXTURE_EMISSION]="texture_emission";
-	shader_names->texture_names[TEXTURE_NORMAL]="texture_normal";
-	shader_names->texture_names[TEXTURE_RIM]="texture_rim";
-	shader_names->texture_names[TEXTURE_CLEARCOAT]="texture_clearcoat";
-	shader_names->texture_names[TEXTURE_FLOWMAP]="texture_flowmap";
-	shader_names->texture_names[TEXTURE_AMBIENT_OCCLUSION]="texture_ambient_occlusion";
-	shader_names->texture_names[TEXTURE_HEIGHT]="texture_height";
-	shader_names->texture_names[TEXTURE_SUBSURFACE_SCATTERING]="texture_subsurface_scattering";
-	shader_names->texture_names[TEXTURE_REFRACTION]="texture_refraction";
-	shader_names->texture_names[TEXTURE_REFRACTION_ROUGHNESS]="texture_refraction_roughness";
-	shader_names->texture_names[TEXTURE_DETAIL_MASK]="texture_detail_mask";
-	shader_names->texture_names[TEXTURE_DETAIL_ALBEDO]="texture_detail_albedo";
-	shader_names->texture_names[TEXTURE_DETAIL_NORMAL]="texture_detail_normal";
-
-}
-
-void FixedSpatialMaterial::finish_shaders(){
+	shader_names = memnew(ShaderNames);
+
+	shader_names->albedo = "albedo";
+	shader_names->specular = "specular";
+	shader_names->roughness = "roughness";
+	shader_names->metalness = "metalness";
+	shader_names->emission = "emission";
+	shader_names->emission_energy = "emission_energy";
+	shader_names->normal_scale = "normal_scale";
+	shader_names->rim = "rim";
+	shader_names->rim_tint = "rim_tint";
+	shader_names->clearcoat = "clearcoat";
+	shader_names->clearcoat_gloss = "clearcoat_gloss";
+	shader_names->anisotropy = "anisotropy_ratio";
+	shader_names->height_scale = "height_scale";
+	shader_names->subsurface_scattering_strength = "subsurface_scattering_strength";
+	shader_names->refraction = "refraction";
+	shader_names->refraction_roughness = "refraction_roughness";
+	shader_names->point_size = "point_size";
+	shader_names->uv1_scale = "uv1_scale";
+	shader_names->uv1_offset = "uv1_offset";
+	shader_names->uv2_scale = "uv2_scale";
+	shader_names->uv2_offset = "uv2_offset";
+
+	shader_names->texture_names[TEXTURE_ALBEDO] = "texture_albedo";
+	shader_names->texture_names[TEXTURE_SPECULAR] = "texture_specular";
+	shader_names->texture_names[TEXTURE_EMISSION] = "texture_emission";
+	shader_names->texture_names[TEXTURE_NORMAL] = "texture_normal";
+	shader_names->texture_names[TEXTURE_RIM] = "texture_rim";
+	shader_names->texture_names[TEXTURE_CLEARCOAT] = "texture_clearcoat";
+	shader_names->texture_names[TEXTURE_FLOWMAP] = "texture_flowmap";
+	shader_names->texture_names[TEXTURE_AMBIENT_OCCLUSION] = "texture_ambient_occlusion";
+	shader_names->texture_names[TEXTURE_HEIGHT] = "texture_height";
+	shader_names->texture_names[TEXTURE_SUBSURFACE_SCATTERING] = "texture_subsurface_scattering";
+	shader_names->texture_names[TEXTURE_REFRACTION] = "texture_refraction";
+	shader_names->texture_names[TEXTURE_REFRACTION_ROUGHNESS] = "texture_refraction_roughness";
+	shader_names->texture_names[TEXTURE_DETAIL_MASK] = "texture_detail_mask";
+	shader_names->texture_names[TEXTURE_DETAIL_ALBEDO] = "texture_detail_albedo";
+	shader_names->texture_names[TEXTURE_DETAIL_NORMAL] = "texture_detail_normal";
+}
+
+void FixedSpatialMaterial::finish_shaders() {
 
 #ifndef NO_THREADS
-	memdelete( material_mutex );
+	memdelete(material_mutex);
 #endif
 
-	memdelete( shader_names );
-
+	memdelete(shader_names);
 }
 
-
-
 void FixedSpatialMaterial::_update_shader() {
 
-	dirty_materials.remove( &element );
+	dirty_materials.remove(&element);
 
 	MaterialKey mk = _compute_key();
-	if (mk.key==current_key.key)
+	if (mk.key == current_key.key)
 		return; //no update required in the end
 
 	if (shader_map.has(current_key)) {
 		shader_map[current_key].users--;
-		if (shader_map[current_key].users==0) {
+		if (shader_map[current_key].users == 0) {
 			//deallocate shader, as it's no longer in use
 			VS::get_singleton()->free(shader_map[current_key].shader);
 			shader_map.erase(current_key);
 		}
 	}
 
-	current_key=mk;
+	current_key = mk;
 
 	if (shader_map.has(mk)) {
 
-		VS::get_singleton()->material_set_shader(_get_material(),shader_map[mk].shader);
+		VS::get_singleton()->material_set_shader(_get_material(), shader_map[mk].shader);
 		shader_map[mk].users++;
 		return;
 	}
 
 	//must create a shader!
 
-	String code="render_mode ";
-	switch(blend_mode) {
-		case BLEND_MODE_MIX: code+="blend_mix"; break;
-		case BLEND_MODE_ADD: code+="blend_add"; break;
-		case BLEND_MODE_SUB: code+="blend_sub"; break;
-		case BLEND_MODE_MUL: code+="blend_mul"; break;
+	String code = "render_mode ";
+	switch (blend_mode) {
+		case BLEND_MODE_MIX: code += "blend_mix"; break;
+		case BLEND_MODE_ADD: code += "blend_add"; break;
+		case BLEND_MODE_SUB: code += "blend_sub"; break;
+		case BLEND_MODE_MUL: code += "blend_mul"; break;
 	}
 
-	switch(depth_draw_mode) {
-		case DEPTH_DRAW_OPAQUE_ONLY: code+=",depth_draw_opaque"; break;
-		case DEPTH_DRAW_ALWAYS: code+=",depth_draw_always"; break;
-		case DEPTH_DRAW_DISABLED: code+=",depth_draw_never"; break;
-		case DEPTH_DRAW_ALPHA_OPAQUE_PREPASS: code+=",depth_draw_alpha_prepass"; break;
+	switch (depth_draw_mode) {
+		case DEPTH_DRAW_OPAQUE_ONLY: code += ",depth_draw_opaque"; break;
+		case DEPTH_DRAW_ALWAYS: code += ",depth_draw_always"; break;
+		case DEPTH_DRAW_DISABLED: code += ",depth_draw_never"; break;
+		case DEPTH_DRAW_ALPHA_OPAQUE_PREPASS: code += ",depth_draw_alpha_prepass"; break;
 	}
 
-	switch(cull_mode) {
-		case CULL_BACK: code+=",cull_back"; break;
-		case CULL_FRONT: code+=",cull_front"; break;
-		case CULL_DISABLED: code+=",cull_disabled"; break;
-
+	switch (cull_mode) {
+		case CULL_BACK: code += ",cull_back"; break;
+		case CULL_FRONT: code += ",cull_front"; break;
+		case CULL_DISABLED: code += ",cull_disabled"; break;
 	}
 
 	if (flags[FLAG_UNSHADED]) {
-		code+=",unshaded";
+		code += ",unshaded";
 	}
 	if (flags[FLAG_ONTOP]) {
-		code+=",ontop";
+		code += ",ontop";
 	}
 
-	code+=";\n";
-
+	code += ";\n";
 
-	code+="uniform vec4 albedo : hint_color;\n";
-	code+="uniform sampler2D texture_albedo : hint_albedo;\n";
-	if (specular_mode==SPECULAR_MODE_SPECULAR) {
-		code+="uniform vec4 specular : hint_color;\n";
+	code += "uniform vec4 albedo : hint_color;\n";
+	code += "uniform sampler2D texture_albedo : hint_albedo;\n";
+	if (specular_mode == SPECULAR_MODE_SPECULAR) {
+		code += "uniform vec4 specular : hint_color;\n";
 	} else {
-		code+="uniform float metalness;\n";
+		code += "uniform float metalness;\n";
 	}
 
-	code+="uniform float roughness : hint_range(0,1);\n";
-	code+="uniform float point_size : hint_range(0,128);\n";
-	code+="uniform sampler2D texture_specular : hint_white;\n";
-	code+="uniform vec2 uv1_scale;\n";
-	code+="uniform vec2 uv1_offset;\n";
-	code+="uniform vec2 uv2_scale;\n";
-	code+="uniform vec2 uv2_offset;\n";
+	code += "uniform float roughness : hint_range(0,1);\n";
+	code += "uniform float point_size : hint_range(0,128);\n";
+	code += "uniform sampler2D texture_specular : hint_white;\n";
+	code += "uniform vec2 uv1_scale;\n";
+	code += "uniform vec2 uv1_offset;\n";
+	code += "uniform vec2 uv2_scale;\n";
+	code += "uniform vec2 uv2_offset;\n";
 
 	if (features[FEATURE_EMISSION]) {
 
-		code+="uniform sampler2D texture_emission : hint_black_albedo;\n";
-		code+="uniform vec4 emission : hint_color;\n";
-		code+="uniform float emission_energy;\n";
+		code += "uniform sampler2D texture_emission : hint_black_albedo;\n";
+		code += "uniform vec4 emission : hint_color;\n";
+		code += "uniform float emission_energy;\n";
 	}
 
 	if (features[FEATURE_NORMAL_MAPPING]) {
-		code+="uniform sampler2D texture_normal : hint_normal;\n";
-		code+="uniform float normal_scale : hint_range(-16,16);\n";
+		code += "uniform sampler2D texture_normal : hint_normal;\n";
+		code += "uniform float normal_scale : hint_range(-16,16);\n";
 	}
 	if (features[FEATURE_RIM]) {
-		code+="uniform float rim : hint_range(0,1);\n";
-		code+="uniform float rim_tint : hint_range(0,1);\n";
-		code+="uniform sampler2D texture_rim : hint_white;\n";
+		code += "uniform float rim : hint_range(0,1);\n";
+		code += "uniform float rim_tint : hint_range(0,1);\n";
+		code += "uniform sampler2D texture_rim : hint_white;\n";
 	}
 	if (features[FEATURE_CLEARCOAT]) {
-		code+="uniform float clearcoat : hint_range(0,1);\n";
-		code+="uniform float clearcoat_gloss : hint_range(0,1);\n";
-		code+="uniform sampler2D texture_clearcoat : hint_white;\n";
+		code += "uniform float clearcoat : hint_range(0,1);\n";
+		code += "uniform float clearcoat_gloss : hint_range(0,1);\n";
+		code += "uniform sampler2D texture_clearcoat : hint_white;\n";
 	}
 	if (features[FEATURE_ANISOTROPY]) {
-		code+="uniform float anisotropy_ratio : hint_range(0,256);\n";
-		code+="uniform sampler2D texture_flowmap : hint_aniso;\n";
+		code += "uniform float anisotropy_ratio : hint_range(0,256);\n";
+		code += "uniform sampler2D texture_flowmap : hint_aniso;\n";
 	}
 	if (features[FEATURE_AMBIENT_OCCLUSION]) {
-		code+="uniform sampler2D texture_ambient_occlusion : hint_white;\n";
+		code += "uniform sampler2D texture_ambient_occlusion : hint_white;\n";
 	}
 
 	if (features[FEATURE_DETAIL]) {
-		code+="uniform sampler2D texture_detail_albedo : hint_albedo;\n";
-		code+="uniform sampler2D texture_detail_normal : hint_normal;\n";
-		code+="uniform sampler2D texture_detail_mask : hint_white;\n";
+		code += "uniform sampler2D texture_detail_albedo : hint_albedo;\n";
+		code += "uniform sampler2D texture_detail_normal : hint_normal;\n";
+		code += "uniform sampler2D texture_detail_mask : hint_white;\n";
 	}
 
 	if (features[FEATURE_SUBSURACE_SCATTERING]) {
 
-		code+="uniform float subsurface_scattering_strength : hint_range(0,1);\n";
-		code+="uniform sampler2D texture_subsurface_scattering : hint_white;\n";
-
+		code += "uniform float subsurface_scattering_strength : hint_range(0,1);\n";
+		code += "uniform sampler2D texture_subsurface_scattering : hint_white;\n";
 	}
 
+	code += "\n\n";
 
-	code+="\n\n";
-
-	code+="void vertex() {\n";
+	code += "void vertex() {\n";
 
 	if (flags[FLAG_SRGB_VERTEX_COLOR]) {
 
-		code+="\tCOLOR.rgb = mix( pow((COLOR.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), COLOR.rgb* (1.0 / 12.92), lessThan(COLOR.rgb,vec3(0.04045)) );\n";
+		code += "\tCOLOR.rgb = mix( pow((COLOR.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), COLOR.rgb* (1.0 / 12.92), lessThan(COLOR.rgb,vec3(0.04045)) );\n";
 	}
 	if (flags[FLAG_USE_POINT_SIZE]) {
 
-		code+="\tPOINT_SIZE=point_size;\n";
+		code += "\tPOINT_SIZE=point_size;\n";
 	}
-	code+="\tUV=UV*uv1_scale+uv1_offset;\n";
-	if (detail_uv==DETAIL_UV_2) {
-		code+="\tUV2=UV2*uv2_scale+uv2_offset;\n";
+	code += "\tUV=UV*uv1_scale+uv1_offset;\n";
+	if (detail_uv == DETAIL_UV_2) {
+		code += "\tUV2=UV2*uv2_scale+uv2_offset;\n";
 	}
 
-	code+="}\n";
-	code+="\n\n";
-	code+="void fragment() {\n";
+	code += "}\n";
+	code += "\n\n";
+	code += "void fragment() {\n";
 
 	if (flags[FLAG_USE_POINT_SIZE]) {
-		code+="\tvec4 albedo_tex = texture(texture_albedo,POINT_COORD);\n";
+		code += "\tvec4 albedo_tex = texture(texture_albedo,POINT_COORD);\n";
 	} else {
-		code+="\tvec4 albedo_tex = texture(texture_albedo,UV);\n";
+		code += "\tvec4 albedo_tex = texture(texture_albedo,UV);\n";
 	}
 
 	if (flags[FLAG_ALBEDO_FROM_VERTEX_COLOR]) {
-		code+="\talbedo_tex *= COLOR;\n";
+		code += "\talbedo_tex *= COLOR;\n";
 	}
 
-	code+="\tALBEDO = albedo.rgb * albedo_tex.rgb;\n";
+	code += "\tALBEDO = albedo.rgb * albedo_tex.rgb;\n";
 	if (features[FEATURE_TRANSPARENT]) {
-		code+="\tALPHA = albedo.a * albedo_tex.a;\n";
+		code += "\tALPHA = albedo.a * albedo_tex.a;\n";
 	}
 
 	if (features[FEATURE_EMISSION]) {
-		code+="\tEMISSION = (emission.rgb+texture(texture_emission,UV).rgb)*emission_energy;\n";
+		code += "\tEMISSION = (emission.rgb+texture(texture_emission,UV).rgb)*emission_energy;\n";
 	}
 
 	if (features[FEATURE_NORMAL_MAPPING]) {
-		code+="\tNORMALMAP = texture(texture_normal,UV).rgb;\n";
-		code+="\tNORMALMAP_DEPTH = normal_scale;\n";
+		code += "\tNORMALMAP = texture(texture_normal,UV).rgb;\n";
+		code += "\tNORMALMAP_DEPTH = normal_scale;\n";
 	}
 
 	if (features[FEATURE_RIM]) {
-		code+="\tvec2 rim_tex = texture(texture_rim,UV).xw;\n";
-		code+="\tRIM = rim*rim_tex.x;";
-		code+="\tRIM_TINT = rim_tint*rim_tex.y;\n";
+		code += "\tvec2 rim_tex = texture(texture_rim,UV).xw;\n";
+		code += "\tRIM = rim*rim_tex.x;";
+		code += "\tRIM_TINT = rim_tint*rim_tex.y;\n";
 	}
 
 	if (features[FEATURE_CLEARCOAT]) {
-		code+="\tvec2 clearcoat_tex = texture(texture_clearcoat,UV).xw;\n";
-		code+="\tCLEARCOAT = clearcoat*clearcoat_tex.x;";
-		code+="\tCLEARCOAT_GLOSS = clearcoat_gloss*clearcoat_tex.y;\n";
+		code += "\tvec2 clearcoat_tex = texture(texture_clearcoat,UV).xw;\n";
+		code += "\tCLEARCOAT = clearcoat*clearcoat_tex.x;";
+		code += "\tCLEARCOAT_GLOSS = clearcoat_gloss*clearcoat_tex.y;\n";
 	}
 
 	if (features[FEATURE_ANISOTROPY]) {
-		code+="\tvec4 anisotropy_tex = texture(texture_flowmap,UV);\n";
-		code+="\tANISOTROPY = anisotropy_ratio*anisotropy_tex.a;\n";
-		code+="\tANISOTROPY_FLOW = anisotropy_tex.rg*2.0-1.0;\n";
+		code += "\tvec4 anisotropy_tex = texture(texture_flowmap,UV);\n";
+		code += "\tANISOTROPY = anisotropy_ratio*anisotropy_tex.a;\n";
+		code += "\tANISOTROPY_FLOW = anisotropy_tex.rg*2.0-1.0;\n";
 	}
 
 	if (features[FEATURE_AMBIENT_OCCLUSION]) {
-		code+="\tAO = texture(texture_ambient_occlusion,UV).r;\n";
+		code += "\tAO = texture(texture_ambient_occlusion,UV).r;\n";
 	}
 
 	if (features[FEATURE_SUBSURACE_SCATTERING]) {
 
-		code+="\tfloat sss_tex = texture(texture_subsurface_scattering,UV).r;\n";
-		code+="\tSSS_STRENGTH=subsurface_scattering_strength*sss_tex;\n";
+		code += "\tfloat sss_tex = texture(texture_subsurface_scattering,UV).r;\n";
+		code += "\tSSS_STRENGTH=subsurface_scattering_strength*sss_tex;\n";
 	}
 
 	if (features[FEATURE_DETAIL]) {
-		String det_uv=detail_uv==DETAIL_UV_1?"UV":"UV2";
-		code+="\tvec4 detail_tex = texture(texture_detail_albedo,"+det_uv+");\n";
-		code+="\tvec4 detail_norm_tex = texture(texture_detail_normal,"+det_uv+");\n";
-		code+="\tvec4 detail_mask_tex = texture(texture_detail_mask,UV);\n";
+		String det_uv = detail_uv == DETAIL_UV_1 ? "UV" : "UV2";
+		code += "\tvec4 detail_tex = texture(texture_detail_albedo," + det_uv + ");\n";
+		code += "\tvec4 detail_norm_tex = texture(texture_detail_normal," + det_uv + ");\n";
+		code += "\tvec4 detail_mask_tex = texture(texture_detail_mask,UV);\n";
 
-		switch(detail_blend_mode) {
+		switch (detail_blend_mode) {
 			case BLEND_MODE_MIX: {
-				code+="\tvec3 detail = mix(ALBEDO.rgb,detail_tex.rgb,detail_tex.a);\n";
+				code += "\tvec3 detail = mix(ALBEDO.rgb,detail_tex.rgb,detail_tex.a);\n";
 			} break;
 			case BLEND_MODE_ADD: {
-				code+="\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb+detail_tex.rgb,detail_tex.a);\n";
+				code += "\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb+detail_tex.rgb,detail_tex.a);\n";
 			} break;
 			case BLEND_MODE_SUB: {
-				code+="\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb-detail_tex.rgb,detail_tex.a);\n";
+				code += "\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb-detail_tex.rgb,detail_tex.a);\n";
 			} break;
 			case BLEND_MODE_MUL: {
-				code+="\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb*detail_tex.rgb,detail_tex.a);\n";
+				code += "\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb*detail_tex.rgb,detail_tex.a);\n";
 			} break;
-
 		}
 
-		code+="\tvec3 detail_norm = mix(NORMALMAP,detail_norm_tex.rgb,detail_tex.a);\n";
+		code += "\tvec3 detail_norm = mix(NORMALMAP,detail_norm_tex.rgb,detail_tex.a);\n";
 
-		code+="\tNORMALMAP = mix(NORMALMAP,detail_norm,detail_mask_tex.r);\n";
-		code+="\tALBEDO.rgb = mix(ALBEDO.rgb,detail,detail_mask_tex.r);\n";
+		code += "\tNORMALMAP = mix(NORMALMAP,detail_norm,detail_mask_tex.r);\n";
+		code += "\tALBEDO.rgb = mix(ALBEDO.rgb,detail,detail_mask_tex.r);\n";
 	}
 
-	if (specular_mode==SPECULAR_MODE_SPECULAR) {
+	if (specular_mode == SPECULAR_MODE_SPECULAR) {
 
-		code+="\tvec4 specular_tex = texture(texture_specular,UV);\n";
-		code+="\tSPECULAR = specular.rgb * specular_tex.rgb;\n";
-		code+="\tROUGHNESS = specular_tex.a * roughness;\n";
+		code += "\tvec4 specular_tex = texture(texture_specular,UV);\n";
+		code += "\tSPECULAR = specular.rgb * specular_tex.rgb;\n";
+		code += "\tROUGHNESS = specular_tex.a * roughness;\n";
 	} else {
-		code+="\tvec4 specular_tex = texture(texture_specular,UV);\n";
-		code+="\tSPECULAR = vec3(ALBEDO.rgb * metalness * specular_tex.r);\n";
-		code+="\tROUGHNESS = specular_tex.a * roughness;\n";
+		code += "\tvec4 specular_tex = texture(texture_specular,UV);\n";
+		code += "\tSPECULAR = vec3(ALBEDO.rgb * metalness * specular_tex.r);\n";
+		code += "\tROUGHNESS = specular_tex.a * roughness;\n";
 	}
 
-	code+="}\n";
+	code += "}\n";
 
 	ShaderData shader_data;
 	shader_data.shader = VS::get_singleton()->shader_create(VS::SHADER_SPATIAL);
-	shader_data.users=1;
-
-	VS::get_singleton()->shader_set_code( shader_data.shader, code );
+	shader_data.users = 1;
 
-	shader_map[mk]=shader_data;
+	VS::get_singleton()->shader_set_code(shader_data.shader, code);
 
-	VS::get_singleton()->material_set_shader(_get_material(),shader_data.shader);
+	shader_map[mk] = shader_data;
 
+	VS::get_singleton()->material_set_shader(_get_material(), shader_data.shader);
 }
 
 void FixedSpatialMaterial::flush_changes() {
@@ -382,38 +371,36 @@ void FixedSpatialMaterial::_queue_shader_change() {
 
 	if (material_mutex)
 		material_mutex->unlock();
-
-
 }
 
 bool FixedSpatialMaterial::_is_shader_dirty() const {
 
-	bool dirty=false;
+	bool dirty = false;
 
 	if (material_mutex)
 		material_mutex->lock();
 
-	dirty=element.in_list();
+	dirty = element.in_list();
 
 	if (material_mutex)
 		material_mutex->unlock();
 
 	return dirty;
 }
-void FixedSpatialMaterial::set_albedo(const Color& p_albedo) {
+void FixedSpatialMaterial::set_albedo(const Color &p_albedo) {
 
-	albedo=p_albedo;
+	albedo = p_albedo;
 
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->albedo,p_albedo);
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->albedo, p_albedo);
 }
 
-Color FixedSpatialMaterial::get_albedo() const{
+Color FixedSpatialMaterial::get_albedo() const {
 
 	return albedo;
 }
 
 void FixedSpatialMaterial::set_specular_mode(SpecularMode p_mode) {
-	specular_mode=p_mode;
+	specular_mode = p_mode;
 	_change_notify();
 	_queue_shader_change();
 }
@@ -423,167 +410,146 @@ FixedSpatialMaterial::SpecularMode FixedSpatialMaterial::get_specular_mode() con
 	return specular_mode;
 }
 
-void FixedSpatialMaterial::set_specular(const Color& p_specular){
-
-	specular=p_specular;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->specular,p_specular);
+void FixedSpatialMaterial::set_specular(const Color &p_specular) {
 
+	specular = p_specular;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->specular, p_specular);
 }
-Color FixedSpatialMaterial::get_specular() const{
+Color FixedSpatialMaterial::get_specular() const {
 
 	return specular;
 }
 
-void FixedSpatialMaterial::set_roughness(float p_roughness){
-
-	roughness=p_roughness;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->roughness,p_roughness);
+void FixedSpatialMaterial::set_roughness(float p_roughness) {
 
+	roughness = p_roughness;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->roughness, p_roughness);
 }
 
-
-float FixedSpatialMaterial::get_roughness() const{
+float FixedSpatialMaterial::get_roughness() const {
 
 	return roughness;
 }
 
-void FixedSpatialMaterial::set_metalness(float p_metalness){
+void FixedSpatialMaterial::set_metalness(float p_metalness) {
 
-	metalness=p_metalness;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->metalness,p_metalness);
+	metalness = p_metalness;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->metalness, p_metalness);
 }
 
-
-float FixedSpatialMaterial::get_metalness() const{
+float FixedSpatialMaterial::get_metalness() const {
 
 	return metalness;
 }
 
-void FixedSpatialMaterial::set_emission(const Color& p_emission){
-
-	emission=p_emission;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->emission,p_emission);
+void FixedSpatialMaterial::set_emission(const Color &p_emission) {
 
+	emission = p_emission;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->emission, p_emission);
 }
-Color FixedSpatialMaterial::get_emission() const{
+Color FixedSpatialMaterial::get_emission() const {
 
 	return emission;
 }
 
+void FixedSpatialMaterial::set_emission_energy(float p_emission_energy) {
 
-void FixedSpatialMaterial::set_emission_energy(float p_emission_energy){
-
-	emission_energy=p_emission_energy;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->emission_energy,p_emission_energy);
-
+	emission_energy = p_emission_energy;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->emission_energy, p_emission_energy);
 }
-float FixedSpatialMaterial::get_emission_energy() const{
+float FixedSpatialMaterial::get_emission_energy() const {
 
 	return emission_energy;
 }
 
-void FixedSpatialMaterial::set_normal_scale(float p_normal_scale){
-
-	normal_scale=p_normal_scale;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->normal_scale,p_normal_scale);
+void FixedSpatialMaterial::set_normal_scale(float p_normal_scale) {
 
+	normal_scale = p_normal_scale;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->normal_scale, p_normal_scale);
 }
-float FixedSpatialMaterial::get_normal_scale() const{
+float FixedSpatialMaterial::get_normal_scale() const {
 
 	return normal_scale;
 }
 
-void FixedSpatialMaterial::set_rim(float p_rim){
-
-	rim=p_rim;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->rim,p_rim);
-
+void FixedSpatialMaterial::set_rim(float p_rim) {
 
+	rim = p_rim;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->rim, p_rim);
 }
-float FixedSpatialMaterial::get_rim() const{
+float FixedSpatialMaterial::get_rim() const {
 
 	return rim;
 }
 
-void FixedSpatialMaterial::set_rim_tint(float p_rim_tint){
-
-	rim_tint=p_rim_tint;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->rim_tint,p_rim_tint);
+void FixedSpatialMaterial::set_rim_tint(float p_rim_tint) {
 
+	rim_tint = p_rim_tint;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->rim_tint, p_rim_tint);
 }
-float FixedSpatialMaterial::get_rim_tint() const{
+float FixedSpatialMaterial::get_rim_tint() const {
 
 	return rim_tint;
 }
 
-void FixedSpatialMaterial::set_clearcoat(float p_clearcoat){
-
-	clearcoat=p_clearcoat;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->clearcoat,p_clearcoat);
+void FixedSpatialMaterial::set_clearcoat(float p_clearcoat) {
 
+	clearcoat = p_clearcoat;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->clearcoat, p_clearcoat);
 }
 
-float FixedSpatialMaterial::get_clearcoat() const{
+float FixedSpatialMaterial::get_clearcoat() const {
 
 	return clearcoat;
 }
 
-void FixedSpatialMaterial::set_clearcoat_gloss(float p_clearcoat_gloss){
-
-	clearcoat_gloss=p_clearcoat_gloss;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->clearcoat_gloss,p_clearcoat_gloss);
-
+void FixedSpatialMaterial::set_clearcoat_gloss(float p_clearcoat_gloss) {
 
+	clearcoat_gloss = p_clearcoat_gloss;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->clearcoat_gloss, p_clearcoat_gloss);
 }
 
-float FixedSpatialMaterial::get_clearcoat_gloss() const{
+float FixedSpatialMaterial::get_clearcoat_gloss() const {
 
 	return clearcoat_gloss;
 }
 
-void FixedSpatialMaterial::set_anisotropy(float p_anisotropy){
-
-	anisotropy=p_anisotropy;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->anisotropy,p_anisotropy);
+void FixedSpatialMaterial::set_anisotropy(float p_anisotropy) {
 
+	anisotropy = p_anisotropy;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->anisotropy, p_anisotropy);
 }
-float FixedSpatialMaterial::get_anisotropy() const{
+float FixedSpatialMaterial::get_anisotropy() const {
 
 	return anisotropy;
 }
 
-void FixedSpatialMaterial::set_height_scale(float p_height_scale){
-
-	height_scale=p_height_scale;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->height_scale,p_height_scale);
-
+void FixedSpatialMaterial::set_height_scale(float p_height_scale) {
 
+	height_scale = p_height_scale;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->height_scale, p_height_scale);
 }
 
-float FixedSpatialMaterial::get_height_scale() const{
+float FixedSpatialMaterial::get_height_scale() const {
 
 	return height_scale;
 }
 
+void FixedSpatialMaterial::set_subsurface_scattering_strength(float p_subsurface_scattering_strength) {
 
-void FixedSpatialMaterial::set_subsurface_scattering_strength(float p_subsurface_scattering_strength){
-
-	subsurface_scattering_strength=p_subsurface_scattering_strength;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->subsurface_scattering_strength,subsurface_scattering_strength);
-
-
+	subsurface_scattering_strength = p_subsurface_scattering_strength;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->subsurface_scattering_strength, subsurface_scattering_strength);
 }
 
-float FixedSpatialMaterial::get_subsurface_scattering_strength() const{
+float FixedSpatialMaterial::get_subsurface_scattering_strength() const {
 
 	return subsurface_scattering_strength;
 }
 
-void FixedSpatialMaterial::set_refraction(float p_refraction){
-
-	refraction=p_refraction;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->refraction,refraction);
+void FixedSpatialMaterial::set_refraction(float p_refraction) {
 
+	refraction = p_refraction;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->refraction, refraction);
 }
 
 float FixedSpatialMaterial::get_refraction() const {
@@ -593,10 +559,8 @@ float FixedSpatialMaterial::get_refraction() const {
 
 void FixedSpatialMaterial::set_refraction_roughness(float p_refraction_roughness) {
 
-	refraction_roughness=p_refraction_roughness;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->refraction_roughness,refraction_roughness);
-
-
+	refraction_roughness = p_refraction_roughness;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->refraction_roughness, refraction_roughness);
 }
 float FixedSpatialMaterial::get_refraction_roughness() const {
 
@@ -605,10 +569,10 @@ float FixedSpatialMaterial::get_refraction_roughness() const {
 
 void FixedSpatialMaterial::set_detail_uv(DetailUV p_detail_uv) {
 
-	if (detail_uv==p_detail_uv)
+	if (detail_uv == p_detail_uv)
 		return;
 
-	detail_uv=p_detail_uv;
+	detail_uv = p_detail_uv;
 	_queue_shader_change();
 }
 FixedSpatialMaterial::DetailUV FixedSpatialMaterial::get_detail_uv() const {
@@ -618,10 +582,10 @@ FixedSpatialMaterial::DetailUV FixedSpatialMaterial::get_detail_uv() const {
 
 void FixedSpatialMaterial::set_blend_mode(BlendMode p_mode) {
 
-	if (blend_mode==p_mode)
+	if (blend_mode == p_mode)
 		return;
 
-	blend_mode=p_mode;
+	blend_mode = p_mode;
 	_queue_shader_change();
 }
 FixedSpatialMaterial::BlendMode FixedSpatialMaterial::get_blend_mode() const {
@@ -631,7 +595,7 @@ FixedSpatialMaterial::BlendMode FixedSpatialMaterial::get_blend_mode() const {
 
 void FixedSpatialMaterial::set_detail_blend_mode(BlendMode p_mode) {
 
-	detail_blend_mode=p_mode;
+	detail_blend_mode = p_mode;
 	_queue_shader_change();
 }
 FixedSpatialMaterial::BlendMode FixedSpatialMaterial::get_detail_blend_mode() const {
@@ -641,10 +605,10 @@ FixedSpatialMaterial::BlendMode FixedSpatialMaterial::get_detail_blend_mode() co
 
 void FixedSpatialMaterial::set_depth_draw_mode(DepthDrawMode p_mode) {
 
-	if (depth_draw_mode==p_mode)
+	if (depth_draw_mode == p_mode)
 		return;
 
-	depth_draw_mode=p_mode;
+	depth_draw_mode = p_mode;
 	_queue_shader_change();
 }
 FixedSpatialMaterial::DepthDrawMode FixedSpatialMaterial::get_depth_draw_mode() const {
@@ -654,10 +618,10 @@ FixedSpatialMaterial::DepthDrawMode FixedSpatialMaterial::get_depth_draw_mode()
 
 void FixedSpatialMaterial::set_cull_mode(CullMode p_mode) {
 
-	if (cull_mode==p_mode)
+	if (cull_mode == p_mode)
 		return;
 
-	cull_mode=p_mode;
+	cull_mode = p_mode;
 	_queue_shader_change();
 }
 FixedSpatialMaterial::CullMode FixedSpatialMaterial::get_cull_mode() const {
@@ -667,10 +631,10 @@ FixedSpatialMaterial::CullMode FixedSpatialMaterial::get_cull_mode() const {
 
 void FixedSpatialMaterial::set_diffuse_mode(DiffuseMode p_mode) {
 
-	if (diffuse_mode==p_mode)
+	if (diffuse_mode == p_mode)
 		return;
 
-	diffuse_mode=p_mode;
+	diffuse_mode = p_mode;
 	_queue_shader_change();
 }
 FixedSpatialMaterial::DiffuseMode FixedSpatialMaterial::get_diffuse_mode() const {
@@ -678,91 +642,84 @@ FixedSpatialMaterial::DiffuseMode FixedSpatialMaterial::get_diffuse_mode() const
 	return diffuse_mode;
 }
 
-void FixedSpatialMaterial::set_flag(Flags p_flag,bool p_enabled) {
+void FixedSpatialMaterial::set_flag(Flags p_flag, bool p_enabled) {
 
-	ERR_FAIL_INDEX(p_flag,FLAG_MAX);
+	ERR_FAIL_INDEX(p_flag, FLAG_MAX);
 
-	if (flags[p_flag]==p_enabled)
+	if (flags[p_flag] == p_enabled)
 		return;
 
-	flags[p_flag]=p_enabled;
+	flags[p_flag] = p_enabled;
 	_queue_shader_change();
 }
 
 bool FixedSpatialMaterial::get_flag(Flags p_flag) const {
 
-	ERR_FAIL_INDEX_V(p_flag,FLAG_MAX,false);
+	ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
 	return flags[p_flag];
 }
 
-void FixedSpatialMaterial::set_feature(Feature p_feature,bool p_enabled) {
+void FixedSpatialMaterial::set_feature(Feature p_feature, bool p_enabled) {
 
-	ERR_FAIL_INDEX(p_feature,FEATURE_MAX);
-	if (features[p_feature]==p_enabled)
+	ERR_FAIL_INDEX(p_feature, FEATURE_MAX);
+	if (features[p_feature] == p_enabled)
 		return;
 
-	features[p_feature]=p_enabled;
+	features[p_feature] = p_enabled;
 	_change_notify();
 	_queue_shader_change();
-
-
 }
 
 bool FixedSpatialMaterial::get_feature(Feature p_feature) const {
 
-	ERR_FAIL_INDEX_V(p_feature,FEATURE_MAX,false);
+	ERR_FAIL_INDEX_V(p_feature, FEATURE_MAX, false);
 	return features[p_feature];
 }
 
-
-
 void FixedSpatialMaterial::set_texture(TextureParam p_param, const Ref<Texture> &p_texture) {
 
-	ERR_FAIL_INDEX(p_param,TEXTURE_MAX);
-	textures[p_param]=p_texture;
+	ERR_FAIL_INDEX(p_param, TEXTURE_MAX);
+	textures[p_param] = p_texture;
 	RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->texture_names[p_param],rid);
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->texture_names[p_param], rid);
 }
 
 Ref<Texture> FixedSpatialMaterial::get_texture(TextureParam p_param) const {
 
-	ERR_FAIL_INDEX_V(p_param,TEXTURE_MAX,Ref<Texture>());
+	ERR_FAIL_INDEX_V(p_param, TEXTURE_MAX, Ref<Texture>());
 	return textures[p_param];
 }
 
-
-void FixedSpatialMaterial::_validate_feature(const String& text, Feature feature,PropertyInfo& property) const {
-	if (property.name.begins_with(text) && property.name!=text+"_enabled" && !features[feature]) {
-		property.usage=0;
+void FixedSpatialMaterial::_validate_feature(const String &text, Feature feature, PropertyInfo &property) const {
+	if (property.name.begins_with(text) && property.name != text + "_enabled" && !features[feature]) {
+		property.usage = 0;
 	}
-
 }
 
-void FixedSpatialMaterial::_validate_property(PropertyInfo& property) const {
-	_validate_feature("normal",FEATURE_NORMAL_MAPPING,property);
-	_validate_feature("emission",FEATURE_EMISSION,property);
-	_validate_feature("rim",FEATURE_RIM,property);
-	_validate_feature("clearcoat",FEATURE_CLEARCOAT,property);
-	_validate_feature("anisotropy",FEATURE_ANISOTROPY,property);
-	_validate_feature("ao",FEATURE_AMBIENT_OCCLUSION,property);
-	_validate_feature("height",FEATURE_HEIGHT_MAPPING,property);
-	_validate_feature("subsurf_scatter",FEATURE_SUBSURACE_SCATTERING,property);
-	_validate_feature("refraction",FEATURE_REFRACTION,property);
-	_validate_feature("detail",FEATURE_DETAIL,property);
-
-	if (property.name=="specular/color" && specular_mode==SPECULAR_MODE_METALLIC) {
-		property.usage=0;
+void FixedSpatialMaterial::_validate_property(PropertyInfo &property) const {
+	_validate_feature("normal", FEATURE_NORMAL_MAPPING, property);
+	_validate_feature("emission", FEATURE_EMISSION, property);
+	_validate_feature("rim", FEATURE_RIM, property);
+	_validate_feature("clearcoat", FEATURE_CLEARCOAT, property);
+	_validate_feature("anisotropy", FEATURE_ANISOTROPY, property);
+	_validate_feature("ao", FEATURE_AMBIENT_OCCLUSION, property);
+	_validate_feature("height", FEATURE_HEIGHT_MAPPING, property);
+	_validate_feature("subsurf_scatter", FEATURE_SUBSURACE_SCATTERING, property);
+	_validate_feature("refraction", FEATURE_REFRACTION, property);
+	_validate_feature("detail", FEATURE_DETAIL, property);
+
+	if (property.name == "specular/color" && specular_mode == SPECULAR_MODE_METALLIC) {
+		property.usage = 0;
 	}
-	if (property.name=="specular/metalness" && specular_mode==SPECULAR_MODE_SPECULAR) {
-		property.usage=0;
+	if (property.name == "specular/metalness" && specular_mode == SPECULAR_MODE_SPECULAR) {
+		property.usage = 0;
 	}
-
 }
 
 void FixedSpatialMaterial::set_line_width(float p_line_width) {
 
-	line_width=p_line_width;
-	VS::get_singleton()->material_set_line_width(_get_material(),line_width);
+	line_width = p_line_width;
+	VS::get_singleton()->material_set_line_width(_get_material(), line_width);
 }
 
 float FixedSpatialMaterial::get_line_width() const {
@@ -772,8 +729,8 @@ float FixedSpatialMaterial::get_line_width() const {
 
 void FixedSpatialMaterial::set_point_size(float p_point_size) {
 
-	point_size=p_point_size;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->point_size,p_point_size);
+	point_size = p_point_size;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->point_size, p_point_size);
 }
 
 float FixedSpatialMaterial::get_point_size() const {
@@ -781,321 +738,312 @@ float FixedSpatialMaterial::get_point_size() const {
 	return point_size;
 }
 
+void FixedSpatialMaterial::set_uv1_scale(const Vector2 &p_scale) {
 
-void FixedSpatialMaterial::set_uv1_scale(const Vector2& p_scale) {
-
-	uv1_scale=p_scale;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->uv1_scale,p_scale);
+	uv1_scale = p_scale;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->uv1_scale, p_scale);
 }
 
-Vector2 FixedSpatialMaterial::get_uv1_scale() const{
+Vector2 FixedSpatialMaterial::get_uv1_scale() const {
 
 	return uv1_scale;
 }
 
-void FixedSpatialMaterial::set_uv1_offset(const Vector2& p_offset){
-
-	uv1_offset=p_offset;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->uv1_offset,p_offset);
+void FixedSpatialMaterial::set_uv1_offset(const Vector2 &p_offset) {
 
+	uv1_offset = p_offset;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->uv1_offset, p_offset);
 }
-Vector2 FixedSpatialMaterial::get_uv1_offset() const{
+Vector2 FixedSpatialMaterial::get_uv1_offset() const {
 
 	return uv1_offset;
 }
 
+void FixedSpatialMaterial::set_uv2_scale(const Vector2 &p_scale) {
 
-void FixedSpatialMaterial::set_uv2_scale(const Vector2& p_scale) {
-
-	uv2_scale=p_scale;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->uv2_scale,p_scale);
+	uv2_scale = p_scale;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->uv2_scale, p_scale);
 }
 
-Vector2 FixedSpatialMaterial::get_uv2_scale() const{
+Vector2 FixedSpatialMaterial::get_uv2_scale() const {
 
 	return uv2_scale;
 }
 
-void FixedSpatialMaterial::set_uv2_offset(const Vector2& p_offset){
-
-	uv2_offset=p_offset;
-	VS::get_singleton()->material_set_param(_get_material(),shader_names->uv2_offset,p_offset);
+void FixedSpatialMaterial::set_uv2_offset(const Vector2 &p_offset) {
 
+	uv2_offset = p_offset;
+	VS::get_singleton()->material_set_param(_get_material(), shader_names->uv2_offset, p_offset);
 }
 
-Vector2 FixedSpatialMaterial::get_uv2_offset() const{
+Vector2 FixedSpatialMaterial::get_uv2_offset() const {
 
 	return uv2_offset;
 }
 
 void FixedSpatialMaterial::_bind_methods() {
 
+	ClassDB::bind_method(D_METHOD("set_albedo", "albedo"), &FixedSpatialMaterial::set_albedo);
+	ClassDB::bind_method(D_METHOD("get_albedo"), &FixedSpatialMaterial::get_albedo);
 
-	ClassDB::bind_method(D_METHOD("set_albedo","albedo"),&FixedSpatialMaterial::set_albedo);
-	ClassDB::bind_method(D_METHOD("get_albedo"),&FixedSpatialMaterial::get_albedo);
+	ClassDB::bind_method(D_METHOD("set_specular_mode", "specular_mode"), &FixedSpatialMaterial::set_specular_mode);
+	ClassDB::bind_method(D_METHOD("get_specular_mode"), &FixedSpatialMaterial::get_specular_mode);
 
-	ClassDB::bind_method(D_METHOD("set_specular_mode","specular_mode"),&FixedSpatialMaterial::set_specular_mode);
-	ClassDB::bind_method(D_METHOD("get_specular_mode"),&FixedSpatialMaterial::get_specular_mode);
+	ClassDB::bind_method(D_METHOD("set_specular", "specular"), &FixedSpatialMaterial::set_specular);
+	ClassDB::bind_method(D_METHOD("get_specular"), &FixedSpatialMaterial::get_specular);
 
-	ClassDB::bind_method(D_METHOD("set_specular","specular"),&FixedSpatialMaterial::set_specular);
-	ClassDB::bind_method(D_METHOD("get_specular"),&FixedSpatialMaterial::get_specular);
+	ClassDB::bind_method(D_METHOD("set_metalness", "metalness"), &FixedSpatialMaterial::set_metalness);
+	ClassDB::bind_method(D_METHOD("get_metalness"), &FixedSpatialMaterial::get_metalness);
 
-	ClassDB::bind_method(D_METHOD("set_metalness","metalness"),&FixedSpatialMaterial::set_metalness);
-	ClassDB::bind_method(D_METHOD("get_metalness"),&FixedSpatialMaterial::get_metalness);
+	ClassDB::bind_method(D_METHOD("set_roughness", "roughness"), &FixedSpatialMaterial::set_roughness);
+	ClassDB::bind_method(D_METHOD("get_roughness"), &FixedSpatialMaterial::get_roughness);
 
-	ClassDB::bind_method(D_METHOD("set_roughness","roughness"),&FixedSpatialMaterial::set_roughness);
-	ClassDB::bind_method(D_METHOD("get_roughness"),&FixedSpatialMaterial::get_roughness);
+	ClassDB::bind_method(D_METHOD("set_emission", "emission"), &FixedSpatialMaterial::set_emission);
+	ClassDB::bind_method(D_METHOD("get_emission"), &FixedSpatialMaterial::get_emission);
 
-	ClassDB::bind_method(D_METHOD("set_emission","emission"),&FixedSpatialMaterial::set_emission);
-	ClassDB::bind_method(D_METHOD("get_emission"),&FixedSpatialMaterial::get_emission);
+	ClassDB::bind_method(D_METHOD("set_emission_energy", "emission_energy"), &FixedSpatialMaterial::set_emission_energy);
+	ClassDB::bind_method(D_METHOD("get_emission_energy"), &FixedSpatialMaterial::get_emission_energy);
 
-	ClassDB::bind_method(D_METHOD("set_emission_energy","emission_energy"),&FixedSpatialMaterial::set_emission_energy);
-	ClassDB::bind_method(D_METHOD("get_emission_energy"),&FixedSpatialMaterial::get_emission_energy);
+	ClassDB::bind_method(D_METHOD("set_normal_scale", "normal_scale"), &FixedSpatialMaterial::set_normal_scale);
+	ClassDB::bind_method(D_METHOD("get_normal_scale"), &FixedSpatialMaterial::get_normal_scale);
 
-	ClassDB::bind_method(D_METHOD("set_normal_scale","normal_scale"),&FixedSpatialMaterial::set_normal_scale);
-	ClassDB::bind_method(D_METHOD("get_normal_scale"),&FixedSpatialMaterial::get_normal_scale);
+	ClassDB::bind_method(D_METHOD("set_rim", "rim"), &FixedSpatialMaterial::set_rim);
+	ClassDB::bind_method(D_METHOD("get_rim"), &FixedSpatialMaterial::get_rim);
 
-	ClassDB::bind_method(D_METHOD("set_rim","rim"),&FixedSpatialMaterial::set_rim);
-	ClassDB::bind_method(D_METHOD("get_rim"),&FixedSpatialMaterial::get_rim);
+	ClassDB::bind_method(D_METHOD("set_rim_tint", "rim_tint"), &FixedSpatialMaterial::set_rim_tint);
+	ClassDB::bind_method(D_METHOD("get_rim_tint"), &FixedSpatialMaterial::get_rim_tint);
 
-	ClassDB::bind_method(D_METHOD("set_rim_tint","rim_tint"),&FixedSpatialMaterial::set_rim_tint);
-	ClassDB::bind_method(D_METHOD("get_rim_tint"),&FixedSpatialMaterial::get_rim_tint);
+	ClassDB::bind_method(D_METHOD("set_clearcoat", "clearcoat"), &FixedSpatialMaterial::set_clearcoat);
+	ClassDB::bind_method(D_METHOD("get_clearcoat"), &FixedSpatialMaterial::get_clearcoat);
 
-	ClassDB::bind_method(D_METHOD("set_clearcoat","clearcoat"),&FixedSpatialMaterial::set_clearcoat);
-	ClassDB::bind_method(D_METHOD("get_clearcoat"),&FixedSpatialMaterial::get_clearcoat);
+	ClassDB::bind_method(D_METHOD("set_clearcoat_gloss", "clearcoat_gloss"), &FixedSpatialMaterial::set_clearcoat_gloss);
+	ClassDB::bind_method(D_METHOD("get_clearcoat_gloss"), &FixedSpatialMaterial::get_clearcoat_gloss);
 
-	ClassDB::bind_method(D_METHOD("set_clearcoat_gloss","clearcoat_gloss"),&FixedSpatialMaterial::set_clearcoat_gloss);
-	ClassDB::bind_method(D_METHOD("get_clearcoat_gloss"),&FixedSpatialMaterial::get_clearcoat_gloss);
+	ClassDB::bind_method(D_METHOD("set_anisotropy", "anisotropy"), &FixedSpatialMaterial::set_anisotropy);
+	ClassDB::bind_method(D_METHOD("get_anisotropy"), &FixedSpatialMaterial::get_anisotropy);
 
-	ClassDB::bind_method(D_METHOD("set_anisotropy","anisotropy"),&FixedSpatialMaterial::set_anisotropy);
-	ClassDB::bind_method(D_METHOD("get_anisotropy"),&FixedSpatialMaterial::get_anisotropy);
+	ClassDB::bind_method(D_METHOD("set_height_scale", "height_scale"), &FixedSpatialMaterial::set_height_scale);
+	ClassDB::bind_method(D_METHOD("get_height_scale"), &FixedSpatialMaterial::get_height_scale);
 
-	ClassDB::bind_method(D_METHOD("set_height_scale","height_scale"),&FixedSpatialMaterial::set_height_scale);
-	ClassDB::bind_method(D_METHOD("get_height_scale"),&FixedSpatialMaterial::get_height_scale);
+	ClassDB::bind_method(D_METHOD("set_subsurface_scattering_strength", "strength"), &FixedSpatialMaterial::set_subsurface_scattering_strength);
+	ClassDB::bind_method(D_METHOD("get_subsurface_scattering_strength"), &FixedSpatialMaterial::get_subsurface_scattering_strength);
 
-	ClassDB::bind_method(D_METHOD("set_subsurface_scattering_strength","strength"),&FixedSpatialMaterial::set_subsurface_scattering_strength);
-	ClassDB::bind_method(D_METHOD("get_subsurface_scattering_strength"),&FixedSpatialMaterial::get_subsurface_scattering_strength);
+	ClassDB::bind_method(D_METHOD("set_refraction", "refraction"), &FixedSpatialMaterial::set_refraction);
+	ClassDB::bind_method(D_METHOD("get_refraction"), &FixedSpatialMaterial::get_refraction);
 
-	ClassDB::bind_method(D_METHOD("set_refraction","refraction"),&FixedSpatialMaterial::set_refraction);
-	ClassDB::bind_method(D_METHOD("get_refraction"),&FixedSpatialMaterial::get_refraction);
+	ClassDB::bind_method(D_METHOD("set_refraction_roughness", "refraction_roughness"), &FixedSpatialMaterial::set_refraction_roughness);
+	ClassDB::bind_method(D_METHOD("get_refraction_roughness"), &FixedSpatialMaterial::get_refraction_roughness);
 
-	ClassDB::bind_method(D_METHOD("set_refraction_roughness","refraction_roughness"),&FixedSpatialMaterial::set_refraction_roughness);
-	ClassDB::bind_method(D_METHOD("get_refraction_roughness"),&FixedSpatialMaterial::get_refraction_roughness);
+	ClassDB::bind_method(D_METHOD("set_line_width", "line_width"), &FixedSpatialMaterial::set_line_width);
+	ClassDB::bind_method(D_METHOD("get_line_width"), &FixedSpatialMaterial::get_line_width);
 
-	ClassDB::bind_method(D_METHOD("set_line_width","line_width"),&FixedSpatialMaterial::set_line_width);
-	ClassDB::bind_method(D_METHOD("get_line_width"),&FixedSpatialMaterial::get_line_width);
+	ClassDB::bind_method(D_METHOD("set_point_size", "point_size"), &FixedSpatialMaterial::set_point_size);
+	ClassDB::bind_method(D_METHOD("get_point_size"), &FixedSpatialMaterial::get_point_size);
 
-	ClassDB::bind_method(D_METHOD("set_point_size","point_size"),&FixedSpatialMaterial::set_point_size);
-	ClassDB::bind_method(D_METHOD("get_point_size"),&FixedSpatialMaterial::get_point_size);
+	ClassDB::bind_method(D_METHOD("set_detail_uv", "detail_uv"), &FixedSpatialMaterial::set_detail_uv);
+	ClassDB::bind_method(D_METHOD("get_detail_uv"), &FixedSpatialMaterial::get_detail_uv);
 
-	ClassDB::bind_method(D_METHOD("set_detail_uv","detail_uv"),&FixedSpatialMaterial::set_detail_uv);
-	ClassDB::bind_method(D_METHOD("get_detail_uv"),&FixedSpatialMaterial::get_detail_uv);
+	ClassDB::bind_method(D_METHOD("set_blend_mode", "blend_mode"), &FixedSpatialMaterial::set_blend_mode);
+	ClassDB::bind_method(D_METHOD("get_blend_mode"), &FixedSpatialMaterial::get_blend_mode);
 
-	ClassDB::bind_method(D_METHOD("set_blend_mode","blend_mode"),&FixedSpatialMaterial::set_blend_mode);
-	ClassDB::bind_method(D_METHOD("get_blend_mode"),&FixedSpatialMaterial::get_blend_mode);
+	ClassDB::bind_method(D_METHOD("set_depth_draw_mode", "depth_draw_mode"), &FixedSpatialMaterial::set_depth_draw_mode);
+	ClassDB::bind_method(D_METHOD("get_depth_draw_mode"), &FixedSpatialMaterial::get_depth_draw_mode);
 
-	ClassDB::bind_method(D_METHOD("set_depth_draw_mode","depth_draw_mode"),&FixedSpatialMaterial::set_depth_draw_mode);
-	ClassDB::bind_method(D_METHOD("get_depth_draw_mode"),&FixedSpatialMaterial::get_depth_draw_mode);
+	ClassDB::bind_method(D_METHOD("set_cull_mode", "cull_mode"), &FixedSpatialMaterial::set_cull_mode);
+	ClassDB::bind_method(D_METHOD("get_cull_mode"), &FixedSpatialMaterial::get_cull_mode);
 
-	ClassDB::bind_method(D_METHOD("set_cull_mode","cull_mode"),&FixedSpatialMaterial::set_cull_mode);
-	ClassDB::bind_method(D_METHOD("get_cull_mode"),&FixedSpatialMaterial::get_cull_mode);
+	ClassDB::bind_method(D_METHOD("set_diffuse_mode", "diffuse_mode"), &FixedSpatialMaterial::set_diffuse_mode);
+	ClassDB::bind_method(D_METHOD("get_diffuse_mode"), &FixedSpatialMaterial::get_diffuse_mode);
 
-	ClassDB::bind_method(D_METHOD("set_diffuse_mode","diffuse_mode"),&FixedSpatialMaterial::set_diffuse_mode);
-	ClassDB::bind_method(D_METHOD("get_diffuse_mode"),&FixedSpatialMaterial::get_diffuse_mode);
+	ClassDB::bind_method(D_METHOD("set_flag", "flag", "enable"), &FixedSpatialMaterial::set_flag);
+	ClassDB::bind_method(D_METHOD("get_flag"), &FixedSpatialMaterial::get_flag);
 
-	ClassDB::bind_method(D_METHOD("set_flag","flag","enable"),&FixedSpatialMaterial::set_flag);
-	ClassDB::bind_method(D_METHOD("get_flag"),&FixedSpatialMaterial::get_flag);
+	ClassDB::bind_method(D_METHOD("set_feature", "feature", "enable"), &FixedSpatialMaterial::set_feature);
+	ClassDB::bind_method(D_METHOD("get_feature", "feature"), &FixedSpatialMaterial::get_feature);
 
-	ClassDB::bind_method(D_METHOD("set_feature","feature","enable"),&FixedSpatialMaterial::set_feature);
-	ClassDB::bind_method(D_METHOD("get_feature","feature"),&FixedSpatialMaterial::get_feature);
+	ClassDB::bind_method(D_METHOD("set_texture", "param:Texture", "texture"), &FixedSpatialMaterial::set_texture);
+	ClassDB::bind_method(D_METHOD("get_texture:Texture", "param:Texture"), &FixedSpatialMaterial::get_texture);
 
-	ClassDB::bind_method(D_METHOD("set_texture","param:Texture","texture"),&FixedSpatialMaterial::set_texture);
-	ClassDB::bind_method(D_METHOD("get_texture:Texture","param:Texture"),&FixedSpatialMaterial::get_texture);
+	ClassDB::bind_method(D_METHOD("set_detail_blend_mode", "detail_blend_mode"), &FixedSpatialMaterial::set_detail_blend_mode);
+	ClassDB::bind_method(D_METHOD("get_detail_blend_mode"), &FixedSpatialMaterial::get_detail_blend_mode);
 
-	ClassDB::bind_method(D_METHOD("set_detail_blend_mode","detail_blend_mode"),&FixedSpatialMaterial::set_detail_blend_mode);
-	ClassDB::bind_method(D_METHOD("get_detail_blend_mode"),&FixedSpatialMaterial::get_detail_blend_mode);
+	ClassDB::bind_method(D_METHOD("set_uv1_scale", "scale"), &FixedSpatialMaterial::set_uv1_scale);
+	ClassDB::bind_method(D_METHOD("get_uv1_scale"), &FixedSpatialMaterial::get_uv1_scale);
 
-	ClassDB::bind_method(D_METHOD("set_uv1_scale","scale"),&FixedSpatialMaterial::set_uv1_scale);
-	ClassDB::bind_method(D_METHOD("get_uv1_scale"),&FixedSpatialMaterial::get_uv1_scale);
+	ClassDB::bind_method(D_METHOD("set_uv1_offset", "offset"), &FixedSpatialMaterial::set_uv1_offset);
+	ClassDB::bind_method(D_METHOD("get_uv1_offset"), &FixedSpatialMaterial::get_uv1_offset);
 
-	ClassDB::bind_method(D_METHOD("set_uv1_offset","offset"),&FixedSpatialMaterial::set_uv1_offset);
-	ClassDB::bind_method(D_METHOD("get_uv1_offset"),&FixedSpatialMaterial::get_uv1_offset);
+	ClassDB::bind_method(D_METHOD("set_uv2_scale", "scale"), &FixedSpatialMaterial::set_uv2_scale);
+	ClassDB::bind_method(D_METHOD("get_uv2_scale"), &FixedSpatialMaterial::get_uv2_scale);
 
-	ClassDB::bind_method(D_METHOD("set_uv2_scale","scale"),&FixedSpatialMaterial::set_uv2_scale);
-	ClassDB::bind_method(D_METHOD("get_uv2_scale"),&FixedSpatialMaterial::get_uv2_scale);
+	ClassDB::bind_method(D_METHOD("set_uv2_offset", "offset"), &FixedSpatialMaterial::set_uv2_offset);
+	ClassDB::bind_method(D_METHOD("get_uv2_offset"), &FixedSpatialMaterial::get_uv2_offset);
 
-	ClassDB::bind_method(D_METHOD("set_uv2_offset","offset"),&FixedSpatialMaterial::set_uv2_offset);
-	ClassDB::bind_method(D_METHOD("get_uv2_offset"),&FixedSpatialMaterial::get_uv2_offset);
-
-	ADD_GROUP("Flags","flags_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"flags_transparent"),"set_feature","get_feature",FEATURE_TRANSPARENT);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"flags_unshaded"),"set_flag","get_flag",FLAG_UNSHADED);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"flags_on_top"),"set_flag","get_flag",FLAG_ONTOP);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"flags_use_point_size"),"set_flag","get_flag",FLAG_USE_POINT_SIZE);
-	ADD_GROUP("Vertex Color","vertex_color");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"vertex_color_use_as_albedo"),"set_flag","get_flag",FLAG_ALBEDO_FROM_VERTEX_COLOR);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"vertex_color_is_srgb"),"set_flag","get_flag",FLAG_SRGB_VERTEX_COLOR);
-
-	ADD_GROUP("Parameters","params_");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"params_diffuse_mode",PROPERTY_HINT_ENUM,"Labert,Lambert Wrap,Oren Nayar,Burley"),"set_diffuse_mode","get_diffuse_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"params_blend_mode",PROPERTY_HINT_ENUM,"Mix,Add,Sub,Mul"),"set_blend_mode","get_blend_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"params_cull_mode",PROPERTY_HINT_ENUM,"Back,Front,Disabled"),"set_cull_mode","get_cull_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"params_depth_draw_mode",PROPERTY_HINT_ENUM,"Opaque Only,Always,Never,Opaque Pre-Pass"),"set_depth_draw_mode","get_depth_draw_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"params_line_width",PROPERTY_HINT_RANGE,"0.1,128,0.1"),"set_line_width","get_line_width");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"params_point_size",PROPERTY_HINT_RANGE,"0.1,128,0.1"),"set_point_size","get_point_size");
-
-	ADD_GROUP("Albedo","albedo_");
-	ADD_PROPERTY(PropertyInfo(Variant::COLOR,"albedo_color"),"set_albedo","get_albedo");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"albedo_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_ALBEDO);
-
-	ADD_GROUP("Specular","specular_");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"specular_mode",PROPERTY_HINT_ENUM,"Metallic,Specular"),"set_specular_mode","get_specular_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::COLOR,"specular_color",PROPERTY_HINT_COLOR_NO_ALPHA),"set_specular","get_specular");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"specular_metalness",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_metalness","get_metalness");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"specular_roughness",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_roughness","get_roughness");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"specular_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_SPECULAR);
-
-	ADD_GROUP("Emission","emission_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"emission_enabled"),"set_feature","get_feature",FEATURE_EMISSION);
-	ADD_PROPERTY(PropertyInfo(Variant::COLOR,"emission_color",PROPERTY_HINT_COLOR_NO_ALPHA),"set_emission","get_emission");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"emission_energy",PROPERTY_HINT_RANGE,"0,16,0.01"),"set_emission_energy","get_emission_energy");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"emission_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_EMISSION);
-
-	ADD_GROUP("NormapMap","normal_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"normal_enabled"),"set_feature","get_feature",FEATURE_NORMAL_MAPPING);
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"normal_scale",PROPERTY_HINT_RANGE,"-16,16,0.01"),"set_normal_scale","get_normal_scale");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"normal_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_NORMAL);
-
-	ADD_GROUP("Rim","rim_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"rim_enabled"),"set_feature","get_feature",FEATURE_RIM);
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"rim_amount",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_rim","get_rim");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"rim_tint",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_rim_tint","get_rim_tint");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"rim_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_RIM);
-
-	ADD_GROUP("Clearcoat","clearcoat_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"clearcoat_enabled"),"set_feature","get_feature",FEATURE_CLEARCOAT);
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"clearcoat_amount",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_clearcoat","get_clearcoat");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"clearcoat_gloss",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_clearcoat_gloss","get_clearcoat_gloss");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"clearcoat_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_CLEARCOAT);
-
-	ADD_GROUP("Anisotropy","anisotropy_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"anisotropy_enabled"),"set_feature","get_feature",FEATURE_ANISOTROPY);
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"anisotropy_anisotropy",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_anisotropy","get_anisotropy");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"anisotropy_flowmap",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_FLOWMAP);
-
-	ADD_GROUP("Ambient Occlusion","ao_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"ao_enabled"),"set_feature","get_feature",FEATURE_AMBIENT_OCCLUSION);
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"ao_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_AMBIENT_OCCLUSION);
-
-	ADD_GROUP("Height","height_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"height_enabled"),"set_feature","get_feature",FEATURE_HEIGHT_MAPPING);
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"height_scale",PROPERTY_HINT_RANGE,"-16,16,0.01"),"set_height_scale","get_height_scale");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"height_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_HEIGHT);
-
-	ADD_GROUP("Subsurf Scatter","subsurf_scatter_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"subsurf_scatter_enabled"),"set_feature","get_feature",FEATURE_SUBSURACE_SCATTERING);
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"subsurf_scatter_strength",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_subsurface_scattering_strength","get_subsurface_scattering_strength");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"subsurf_scatter_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_SUBSURFACE_SCATTERING);
-
-	ADD_GROUP("Refraction","refraction_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"refraction_enabled"),"set_feature","get_feature",FEATURE_REFRACTION);
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"refraction_displacement",PROPERTY_HINT_RANGE,"-1,1,0.01"),"set_refraction","get_refraction");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"refraction_roughness",PROPERTY_HINT_RANGE,"0,1,0.01"),"set_refraction_roughness","get_refraction_roughness");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"refraction_texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_REFRACTION);
-
-	ADD_GROUP("Detail","detail_");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL,"detail_enabled"),"set_feature","get_feature",FEATURE_DETAIL);
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"detail_mask",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_DETAIL_MASK);
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"detail_blend_mode",PROPERTY_HINT_ENUM,"Mix,Add,Sub,Mul"),"set_detail_blend_mode","get_detail_blend_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"detail_uv_layer",PROPERTY_HINT_ENUM,"UV1,UV2"),"set_detail_uv","get_detail_uv");
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"detail_albedo",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_DETAIL_ALBEDO);
-	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT,"detail_normal",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),"set_texture","get_texture",TEXTURE_DETAIL_NORMAL);
-
-	ADD_GROUP("UV1","uv1_");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"uv1_scale"),"set_uv1_scale","get_uv1_scale");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"uv1_offset"),"set_uv1_offset","get_uv1_offset");
-
-	ADD_GROUP("UV2","uv2_");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"uv2_scale"),"set_uv2_scale","get_uv2_scale");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2,"uv2_offset"),"set_uv2_offset","get_uv2_offset");
-
-
-	BIND_CONSTANT( TEXTURE_ALBEDO );
-	BIND_CONSTANT( TEXTURE_SPECULAR );
-	BIND_CONSTANT( TEXTURE_EMISSION );
-	BIND_CONSTANT( TEXTURE_NORMAL );
-	BIND_CONSTANT( TEXTURE_RIM );
-	BIND_CONSTANT( TEXTURE_CLEARCOAT );
-	BIND_CONSTANT( TEXTURE_FLOWMAP );
-	BIND_CONSTANT( TEXTURE_AMBIENT_OCCLUSION );
-	BIND_CONSTANT( TEXTURE_HEIGHT );
-	BIND_CONSTANT( TEXTURE_SUBSURFACE_SCATTERING );
-	BIND_CONSTANT( TEXTURE_REFRACTION );
-	BIND_CONSTANT( TEXTURE_REFRACTION_ROUGHNESS );
-	BIND_CONSTANT( TEXTURE_DETAIL_MASK );
-	BIND_CONSTANT( TEXTURE_DETAIL_ALBEDO );
-	BIND_CONSTANT( TEXTURE_DETAIL_NORMAL );
-	BIND_CONSTANT( TEXTURE_MAX );
-
-
-	BIND_CONSTANT( DETAIL_UV_1 );
-	BIND_CONSTANT( DETAIL_UV_2 );
-
-	BIND_CONSTANT( FEATURE_TRANSPARENT );
-	BIND_CONSTANT( FEATURE_EMISSION );
-	BIND_CONSTANT( FEATURE_NORMAL_MAPPING );
-	BIND_CONSTANT( FEATURE_RIM );
-	BIND_CONSTANT( FEATURE_CLEARCOAT );
-	BIND_CONSTANT( FEATURE_ANISOTROPY );
-	BIND_CONSTANT( FEATURE_AMBIENT_OCCLUSION );
-	BIND_CONSTANT( FEATURE_HEIGHT_MAPPING );
-	BIND_CONSTANT( FEATURE_SUBSURACE_SCATTERING );
-	BIND_CONSTANT( FEATURE_REFRACTION );
-	BIND_CONSTANT( FEATURE_DETAIL );
-	BIND_CONSTANT( FEATURE_MAX );
-
-	BIND_CONSTANT( BLEND_MODE_MIX );
-	BIND_CONSTANT( BLEND_MODE_ADD );
-	BIND_CONSTANT( BLEND_MODE_SUB );
-	BIND_CONSTANT( BLEND_MODE_MUL );
-
-	BIND_CONSTANT( DEPTH_DRAW_OPAQUE_ONLY );
-	BIND_CONSTANT( DEPTH_DRAW_ALWAYS );
-	BIND_CONSTANT( DEPTH_DRAW_DISABLED );
-	BIND_CONSTANT( DEPTH_DRAW_ALPHA_OPAQUE_PREPASS );
-
-
-	BIND_CONSTANT( CULL_BACK );
-	BIND_CONSTANT( CULL_FRONT );
-	BIND_CONSTANT( CULL_DISABLED );
-
-	BIND_CONSTANT( FLAG_UNSHADED );
-	BIND_CONSTANT( FLAG_ONTOP );
-	BIND_CONSTANT( FLAG_ALBEDO_FROM_VERTEX_COLOR );
-	BIND_CONSTANT( FLAG_SRGB_VERTEX_COLOR )
-	BIND_CONSTANT( FLAG_USE_POINT_SIZE )
-	BIND_CONSTANT( FLAG_MAX );
-
-	BIND_CONSTANT( DIFFUSE_LAMBERT );
-	BIND_CONSTANT( DIFFUSE_LAMBERT_WRAP );
-	BIND_CONSTANT( DIFFUSE_OREN_NAYAR );
-	BIND_CONSTANT( DIFFUSE_BURLEY );
-
-	BIND_CONSTANT( SPECULAR_MODE_METALLIC );
-	BIND_CONSTANT( SPECULAR_MODE_SPECULAR );
-
-}
-
-
-FixedSpatialMaterial::FixedSpatialMaterial() : element(this) {
+	ADD_GROUP("Flags", "flags_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "flags_transparent"), "set_feature", "get_feature", FEATURE_TRANSPARENT);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "flags_unshaded"), "set_flag", "get_flag", FLAG_UNSHADED);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "flags_on_top"), "set_flag", "get_flag", FLAG_ONTOP);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "flags_use_point_size"), "set_flag", "get_flag", FLAG_USE_POINT_SIZE);
+	ADD_GROUP("Vertex Color", "vertex_color");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "vertex_color_use_as_albedo"), "set_flag", "get_flag", FLAG_ALBEDO_FROM_VERTEX_COLOR);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "vertex_color_is_srgb"), "set_flag", "get_flag", FLAG_SRGB_VERTEX_COLOR);
+
+	ADD_GROUP("Parameters", "params_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "params_diffuse_mode", PROPERTY_HINT_ENUM, "Labert,Lambert Wrap,Oren Nayar,Burley"), "set_diffuse_mode", "get_diffuse_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "params_blend_mode", PROPERTY_HINT_ENUM, "Mix,Add,Sub,Mul"), "set_blend_mode", "get_blend_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "params_cull_mode", PROPERTY_HINT_ENUM, "Back,Front,Disabled"), "set_cull_mode", "get_cull_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "params_depth_draw_mode", PROPERTY_HINT_ENUM, "Opaque Only,Always,Never,Opaque Pre-Pass"), "set_depth_draw_mode", "get_depth_draw_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "params_line_width", PROPERTY_HINT_RANGE, "0.1,128,0.1"), "set_line_width", "get_line_width");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "params_point_size", PROPERTY_HINT_RANGE, "0.1,128,0.1"), "set_point_size", "get_point_size");
+
+	ADD_GROUP("Albedo", "albedo_");
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "albedo_color"), "set_albedo", "get_albedo");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "albedo_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_ALBEDO);
+
+	ADD_GROUP("Specular", "specular_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "specular_mode", PROPERTY_HINT_ENUM, "Metallic,Specular"), "set_specular_mode", "get_specular_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "specular_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_specular", "get_specular");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "specular_metalness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_metalness", "get_metalness");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "specular_roughness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_roughness", "get_roughness");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "specular_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_SPECULAR);
+
+	ADD_GROUP("Emission", "emission_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "emission_enabled"), "set_feature", "get_feature", FEATURE_EMISSION);
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "emission_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_emission", "get_emission");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "emission_energy", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_emission_energy", "get_emission_energy");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "emission_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_EMISSION);
+
+	ADD_GROUP("NormapMap", "normal_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "normal_enabled"), "set_feature", "get_feature", FEATURE_NORMAL_MAPPING);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "normal_scale", PROPERTY_HINT_RANGE, "-16,16,0.01"), "set_normal_scale", "get_normal_scale");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "normal_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_NORMAL);
+
+	ADD_GROUP("Rim", "rim_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "rim_enabled"), "set_feature", "get_feature", FEATURE_RIM);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "rim_amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_rim", "get_rim");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "rim_tint", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_rim_tint", "get_rim_tint");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "rim_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_RIM);
+
+	ADD_GROUP("Clearcoat", "clearcoat_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "clearcoat_enabled"), "set_feature", "get_feature", FEATURE_CLEARCOAT);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "clearcoat_amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_clearcoat", "get_clearcoat");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "clearcoat_gloss", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_clearcoat_gloss", "get_clearcoat_gloss");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "clearcoat_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_CLEARCOAT);
+
+	ADD_GROUP("Anisotropy", "anisotropy_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "anisotropy_enabled"), "set_feature", "get_feature", FEATURE_ANISOTROPY);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "anisotropy_anisotropy", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_anisotropy", "get_anisotropy");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "anisotropy_flowmap", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_FLOWMAP);
+
+	ADD_GROUP("Ambient Occlusion", "ao_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "ao_enabled"), "set_feature", "get_feature", FEATURE_AMBIENT_OCCLUSION);
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "ao_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_AMBIENT_OCCLUSION);
+
+	ADD_GROUP("Height", "height_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "height_enabled"), "set_feature", "get_feature", FEATURE_HEIGHT_MAPPING);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "height_scale", PROPERTY_HINT_RANGE, "-16,16,0.01"), "set_height_scale", "get_height_scale");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "height_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_HEIGHT);
+
+	ADD_GROUP("Subsurf Scatter", "subsurf_scatter_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "subsurf_scatter_enabled"), "set_feature", "get_feature", FEATURE_SUBSURACE_SCATTERING);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "subsurf_scatter_strength", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_subsurface_scattering_strength", "get_subsurface_scattering_strength");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "subsurf_scatter_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_SUBSURFACE_SCATTERING);
+
+	ADD_GROUP("Refraction", "refraction_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "refraction_enabled"), "set_feature", "get_feature", FEATURE_REFRACTION);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "refraction_displacement", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_refraction", "get_refraction");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "refraction_roughness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_refraction_roughness", "get_refraction_roughness");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "refraction_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_REFRACTION);
+
+	ADD_GROUP("Detail", "detail_");
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "detail_enabled"), "set_feature", "get_feature", FEATURE_DETAIL);
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_mask", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_DETAIL_MASK);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "detail_blend_mode", PROPERTY_HINT_ENUM, "Mix,Add,Sub,Mul"), "set_detail_blend_mode", "get_detail_blend_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "detail_uv_layer", PROPERTY_HINT_ENUM, "UV1,UV2"), "set_detail_uv", "get_detail_uv");
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_albedo", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_DETAIL_ALBEDO);
+	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_normal", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture", TEXTURE_DETAIL_NORMAL);
+
+	ADD_GROUP("UV1", "uv1_");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "uv1_scale"), "set_uv1_scale", "get_uv1_scale");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "uv1_offset"), "set_uv1_offset", "get_uv1_offset");
+
+	ADD_GROUP("UV2", "uv2_");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "uv2_scale"), "set_uv2_scale", "get_uv2_scale");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "uv2_offset"), "set_uv2_offset", "get_uv2_offset");
+
+	BIND_CONSTANT(TEXTURE_ALBEDO);
+	BIND_CONSTANT(TEXTURE_SPECULAR);
+	BIND_CONSTANT(TEXTURE_EMISSION);
+	BIND_CONSTANT(TEXTURE_NORMAL);
+	BIND_CONSTANT(TEXTURE_RIM);
+	BIND_CONSTANT(TEXTURE_CLEARCOAT);
+	BIND_CONSTANT(TEXTURE_FLOWMAP);
+	BIND_CONSTANT(TEXTURE_AMBIENT_OCCLUSION);
+	BIND_CONSTANT(TEXTURE_HEIGHT);
+	BIND_CONSTANT(TEXTURE_SUBSURFACE_SCATTERING);
+	BIND_CONSTANT(TEXTURE_REFRACTION);
+	BIND_CONSTANT(TEXTURE_REFRACTION_ROUGHNESS);
+	BIND_CONSTANT(TEXTURE_DETAIL_MASK);
+	BIND_CONSTANT(TEXTURE_DETAIL_ALBEDO);
+	BIND_CONSTANT(TEXTURE_DETAIL_NORMAL);
+	BIND_CONSTANT(TEXTURE_MAX);
+
+	BIND_CONSTANT(DETAIL_UV_1);
+	BIND_CONSTANT(DETAIL_UV_2);
+
+	BIND_CONSTANT(FEATURE_TRANSPARENT);
+	BIND_CONSTANT(FEATURE_EMISSION);
+	BIND_CONSTANT(FEATURE_NORMAL_MAPPING);
+	BIND_CONSTANT(FEATURE_RIM);
+	BIND_CONSTANT(FEATURE_CLEARCOAT);
+	BIND_CONSTANT(FEATURE_ANISOTROPY);
+	BIND_CONSTANT(FEATURE_AMBIENT_OCCLUSION);
+	BIND_CONSTANT(FEATURE_HEIGHT_MAPPING);
+	BIND_CONSTANT(FEATURE_SUBSURACE_SCATTERING);
+	BIND_CONSTANT(FEATURE_REFRACTION);
+	BIND_CONSTANT(FEATURE_DETAIL);
+	BIND_CONSTANT(FEATURE_MAX);
+
+	BIND_CONSTANT(BLEND_MODE_MIX);
+	BIND_CONSTANT(BLEND_MODE_ADD);
+	BIND_CONSTANT(BLEND_MODE_SUB);
+	BIND_CONSTANT(BLEND_MODE_MUL);
+
+	BIND_CONSTANT(DEPTH_DRAW_OPAQUE_ONLY);
+	BIND_CONSTANT(DEPTH_DRAW_ALWAYS);
+	BIND_CONSTANT(DEPTH_DRAW_DISABLED);
+	BIND_CONSTANT(DEPTH_DRAW_ALPHA_OPAQUE_PREPASS);
+
+	BIND_CONSTANT(CULL_BACK);
+	BIND_CONSTANT(CULL_FRONT);
+	BIND_CONSTANT(CULL_DISABLED);
+
+	BIND_CONSTANT(FLAG_UNSHADED);
+	BIND_CONSTANT(FLAG_ONTOP);
+	BIND_CONSTANT(FLAG_ALBEDO_FROM_VERTEX_COLOR);
+	BIND_CONSTANT(FLAG_SRGB_VERTEX_COLOR)
+	BIND_CONSTANT(FLAG_USE_POINT_SIZE)
+	BIND_CONSTANT(FLAG_MAX);
+
+	BIND_CONSTANT(DIFFUSE_LAMBERT);
+	BIND_CONSTANT(DIFFUSE_LAMBERT_WRAP);
+	BIND_CONSTANT(DIFFUSE_OREN_NAYAR);
+	BIND_CONSTANT(DIFFUSE_BURLEY);
+
+	BIND_CONSTANT(SPECULAR_MODE_METALLIC);
+	BIND_CONSTANT(SPECULAR_MODE_SPECULAR);
+}
+
+FixedSpatialMaterial::FixedSpatialMaterial()
+	: element(this) {
 
 	//initialize to right values
-	specular_mode=SPECULAR_MODE_METALLIC;
-	set_albedo(Color(0.7,0.7,0.7,1.0));
-	set_specular(Color(0.1,0.1,0.1));
+	specular_mode = SPECULAR_MODE_METALLIC;
+	set_albedo(Color(0.7, 0.7, 0.7, 1.0));
+	set_specular(Color(0.1, 0.1, 0.1));
 	set_roughness(0.0);
 	set_metalness(0.1);
-	set_emission(Color(0,0,0));
+	set_emission(Color(0, 0, 0));
 	set_emission_energy(1.0);
 	set_normal_scale(1);
 	set_rim(1.0);
@@ -1109,27 +1057,27 @@ FixedSpatialMaterial::FixedSpatialMaterial() : element(this) {
 	set_refraction_roughness(0);
 	set_line_width(1);
 	set_point_size(1);
-	set_uv1_offset(Vector2(0,0));
-	set_uv1_scale(Vector2(1,1));
-	set_uv2_offset(Vector2(0,0));
-	set_uv2_scale(Vector2(1,1));
-
-	detail_uv=DETAIL_UV_1;
-	blend_mode=BLEND_MODE_MIX;
-	detail_blend_mode=BLEND_MODE_MIX;
-	depth_draw_mode=DEPTH_DRAW_OPAQUE_ONLY;
-	cull_mode=CULL_BACK;
-	for(int i=0;i<FLAG_MAX;i++) {
-		flags[i]=0;
+	set_uv1_offset(Vector2(0, 0));
+	set_uv1_scale(Vector2(1, 1));
+	set_uv2_offset(Vector2(0, 0));
+	set_uv2_scale(Vector2(1, 1));
+
+	detail_uv = DETAIL_UV_1;
+	blend_mode = BLEND_MODE_MIX;
+	detail_blend_mode = BLEND_MODE_MIX;
+	depth_draw_mode = DEPTH_DRAW_OPAQUE_ONLY;
+	cull_mode = CULL_BACK;
+	for (int i = 0; i < FLAG_MAX; i++) {
+		flags[i] = 0;
 	}
-	diffuse_mode=DIFFUSE_LAMBERT;
+	diffuse_mode = DIFFUSE_LAMBERT;
 
-	for(int i=0;i<FEATURE_MAX;i++) {
-		features[i]=false;
+	for (int i = 0; i < FEATURE_MAX; i++) {
+		features[i] = false;
 	}
 
-	current_key.key=0;
-	current_key.invalid_key=1;
+	current_key.key = 0;
+	current_key.invalid_key = 1;
 	_queue_shader_change();
 }
 
@@ -1140,17 +1088,15 @@ FixedSpatialMaterial::~FixedSpatialMaterial() {
 
 	if (shader_map.has(current_key)) {
 		shader_map[current_key].users--;
-		if (shader_map[current_key].users==0) {
+		if (shader_map[current_key].users == 0) {
 			//deallocate shader, as it's no longer in use
 			VS::get_singleton()->free(shader_map[current_key].shader);
 			shader_map.erase(current_key);
 		}
 
-		VS::get_singleton()->material_set_shader(_get_material(),RID());
+		VS::get_singleton()->material_set_shader(_get_material(), RID());
 	}
 
-
 	if (material_mutex)
 		material_mutex->unlock();
-
 }