Alpha Hash and Alpha2Coverage Implementation

2 files changed, 243 insertions, 61 deletions

diff --git a/scene/resources/material.cpp b/scene/resources/material.cpp
index 1e95a35726..a5f8cdaf88 100644
--- a/scene/resources/material.cpp
+++ b/scene/resources/material.cpp
@@ -324,7 +324,6 @@ void BaseMaterial3D::init_shaders() {
 	shader_names->rim_texture_channel = "rim_texture_channel";
 	shader_names->heightmap_texture_channel = "heightmap_texture_channel";
 	shader_names->refraction_texture_channel = "refraction_texture_channel";
-	shader_names->alpha_scissor_threshold = "alpha_scissor_threshold";
 
 	shader_names->transmittance_color = "transmittance_color";
 	shader_names->transmittance_curve = "transmittance_curve";
@@ -349,6 +348,12 @@ void BaseMaterial3D::init_shaders() {
 	shader_names->texture_names[TEXTURE_DETAIL_ALBEDO] = "texture_detail_albedo";
 	shader_names->texture_names[TEXTURE_DETAIL_NORMAL] = "texture_detail_normal";
 	shader_names->texture_names[TEXTURE_ORM] = "texture_orm";
+
+	shader_names->alpha_scissor_threshold = "alpha_scissor_threshold";
+	shader_names->alpha_hash_scale = "alpha_hash_scale";
+
+	shader_names->alpha_antialiasing_edge = "alpha_antialiasing_edge";
+	shader_names->albedo_texture_size = "albedo_texture_size";
 }
 
 Ref<StandardMaterial3D> BaseMaterial3D::materials_for_2d[BaseMaterial3D::MAX_MATERIALS_FOR_2D];
@@ -435,6 +440,8 @@ void BaseMaterial3D::_update_shader() {
 		case BLEND_MODE_MUL:
 			code += "blend_mul";
 			break;
+		case BLEND_MODE_MAX:
+			break; // Internal value, skip.
 	}
 
 	DepthDrawMode ddm = depth_draw_mode;
@@ -452,10 +459,8 @@ void BaseMaterial3D::_update_shader() {
 		case DEPTH_DRAW_DISABLED:
 			code += ",depth_draw_never";
 			break;
-	}
-
-	if (transparency == TRANSPARENCY_ALPHA_DEPTH_PRE_PASS) {
-		code += ",depth_prepass_alpha";
+		case DEPTH_DRAW_MAX:
+			break; // Internal value, skip.
 	}
 
 	switch (cull_mode) {
@@ -468,6 +473,8 @@ void BaseMaterial3D::_update_shader() {
 		case CULL_DISABLED:
 			code += ",cull_disabled";
 			break;
+		case CULL_MAX:
+			break; // Internal value, skip.
 	}
 	switch (diffuse_mode) {
 		case DIFFUSE_BURLEY:
@@ -485,6 +492,8 @@ void BaseMaterial3D::_update_shader() {
 		case DIFFUSE_TOON:
 			code += ",diffuse_toon";
 			break;
+		case DIFFUSE_MAX:
+			break; // Internal value, skip.
 	}
 	switch (specular_mode) {
 		case SPECULAR_SCHLICK_GGX:
@@ -502,6 +511,8 @@ void BaseMaterial3D::_update_shader() {
 		case SPECULAR_DISABLED:
 			code += ",specular_disabled";
 			break;
+		case SPECULAR_MAX:
+			break; // Internal value, skip.
 	}
 	if (features[FEATURE_SUBSURFACE_SCATTERING] && flags[FLAG_SUBSURFACE_MODE_SKIN]) {
 		code += ",sss_mode_skin";
@@ -525,6 +536,23 @@ void BaseMaterial3D::_update_shader() {
 	if (flags[FLAG_USE_SHADOW_TO_OPACITY]) {
 		code += ",shadow_to_opacity";
 	}
+
+	if (transparency == TRANSPARENCY_ALPHA_DEPTH_PRE_PASS) {
+		code += ",depth_prepass_alpha";
+	}
+
+	// Although its technically possible to do alpha antialiasing without using alpha hash or alpha scissor,
+	// it is restricted in the base material because it has no use, and abusing it with regular Alpha blending can
+	// saturate the MSAA mask
+	if (transparency == TRANSPARENCY_ALPHA_HASH || transparency == TRANSPARENCY_ALPHA_SCISSOR) {
+		// alpha antialiasing is only useful in ALPHA_HASH or ALPHA_SCISSOR
+		if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE) {
+			code += ",alpha_to_coverage";
+		} else if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE) {
+			code += ",alpha_to_coverage_and_one";
+		}
+	}
+
 	code += ";\n";
 
 	code += "uniform vec4 albedo : hint_color;\n";
@@ -541,8 +569,18 @@ void BaseMaterial3D::_update_shader() {
 		code += "uniform float distance_fade_max;\n";
 	}
 
+	// alpha scissor is only valid if there is not antialiasing edge
+	// alpha hash is valid whenever, but not with alpha scissor
 	if (transparency == TRANSPARENCY_ALPHA_SCISSOR) {
 		code += "uniform float alpha_scissor_threshold;\n";
+	} else if (transparency == TRANSPARENCY_ALPHA_HASH) {
+		code += "uniform float alpha_hash_scale;\n";
+	}
+	// if alpha antialiasing isn't off, add in the edge variable
+	if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF &&
+			(transparency == TRANSPARENCY_ALPHA_SCISSOR || transparency == TRANSPARENCY_ALPHA_HASH)) {
+		code += "uniform float alpha_antialiasing_edge;\n";
+		code += "uniform ivec2 albedo_texture_size;\n";
 	}
 
 	code += "uniform float point_size : hint_range(0,128);\n";
@@ -568,6 +606,8 @@ void BaseMaterial3D::_update_shader() {
 			case TEXTURE_CHANNEL_GRAYSCALE: {
 				code += "uniform sampler2D texture_roughness : hint_roughness_gray," + texfilter_str + ";\n";
 			} break;
+			case TEXTURE_CHANNEL_MAX:
+				break; // Internal value, skip.
 		}
 
 		code += "uniform float specular;\n";
@@ -731,6 +771,8 @@ void BaseMaterial3D::_update_shader() {
 			code += "\tUV /= vec2(h_frames, v_frames);\n";
 			code += "\tUV += vec2(mod(particle_frame, h_frames) / h_frames, floor(particle_frame / h_frames) / v_frames);\n";
 		} break;
+		case BILLBOARD_MAX:
+			break; // Internal value, skip.
 	}
 
 	if (flags[FLAG_FIXED_SIZE]) {
@@ -903,6 +945,8 @@ void BaseMaterial3D::_update_shader() {
 			case TEXTURE_CHANNEL_GRAYSCALE: {
 				code += "\tvec4 roughness_texture_channel = vec4(0.333333,0.333333,0.333333,0.0);\n";
 			} break;
+			case TEXTURE_CHANNEL_MAX:
+				break; // Internal value, skip.
 		}
 
 		if (flags[FLAG_UV1_USE_TRIPLANAR]) {
@@ -970,10 +1014,17 @@ void BaseMaterial3D::_update_shader() {
 		code += "\tALBEDO *= 1.0 - ref_amount;\n";
 		code += "\tALPHA = 1.0;\n";
 
-	} else if (transparency == TRANSPARENCY_ALPHA || transparency == TRANSPARENCY_ALPHA_DEPTH_PRE_PASS || flags[FLAG_USE_SHADOW_TO_OPACITY] || (distance_fade == DISTANCE_FADE_PIXEL_ALPHA) || proximity_fade_enabled) {
+	} else if (transparency != TRANSPARENCY_DISABLED || flags[FLAG_USE_SHADOW_TO_OPACITY] || (distance_fade == DISTANCE_FADE_PIXEL_ALPHA) || proximity_fade_enabled) {
 		code += "\tALPHA = albedo.a * albedo_tex.a;\n";
+	}
+	if (transparency == TRANSPARENCY_ALPHA_HASH) {
+		code += "\tALPHA_HASH_SCALE = alpha_hash_scale;\n";
 	} else if (transparency == TRANSPARENCY_ALPHA_SCISSOR) {
-		code += "\tif (albedo.a * albedo_tex.a < alpha_scissor_threshold) discard;\n";
+		code += "\tALPHA_SCISSOR_THRESHOLD = alpha_scissor_threshold;\n";
+	}
+	if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF && (transparency == TRANSPARENCY_ALPHA_HASH || transparency == TRANSPARENCY_ALPHA_SCISSOR)) {
+		code += "\tALPHA_ANTIALIASING_EDGE = alpha_antialiasing_edge;\n";
+		code += "\tALPHA_TEXTURE_COORDINATE = UV * vec2(albedo_texture_size);\n";
 	}
 
 	if (proximity_fade_enabled) {
@@ -1143,6 +1194,8 @@ void BaseMaterial3D::_update_shader() {
 			case BLEND_MODE_MUL: {
 				code += "\tvec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb*detail_tex.rgb,detail_tex.a);\n";
 			} break;
+			case BLEND_MODE_MAX:
+				break; // Internal value, skip.
 		}
 
 		code += "\tvec3 detail_norm = mix(NORMALMAP,detail_norm_tex.rgb,detail_tex.a);\n";
@@ -1424,6 +1477,20 @@ BaseMaterial3D::Transparency BaseMaterial3D::get_transparency() const {
 	return transparency;
 }
 
+void BaseMaterial3D::set_alpha_antialiasing(AlphaAntiAliasing p_alpha_aa) {
+	if (alpha_antialiasing_mode == p_alpha_aa) {
+		return;
+	}
+
+	alpha_antialiasing_mode = p_alpha_aa;
+	_queue_shader_change();
+	_change_notify();
+}
+
+BaseMaterial3D::AlphaAntiAliasing BaseMaterial3D::get_alpha_antialiasing() const {
+	return alpha_antialiasing_mode;
+}
+
 void BaseMaterial3D::set_shading_mode(ShadingMode p_shading_mode) {
 	if (shading_mode == p_shading_mode) {
 		return;
@@ -1530,6 +1597,10 @@ void BaseMaterial3D::set_texture(TextureParam p_param, const Ref<Texture2D> &p_t
 	textures[p_param] = p_texture;
 	RID rid = p_texture.is_valid() ? p_texture->get_rid() : RID();
 	RS::get_singleton()->material_set_param(_get_material(), shader_names->texture_names[p_param], rid);
+	if (p_texture.is_valid() && p_param == TEXTURE_ALBEDO) {
+		RS::get_singleton()->material_set_param(_get_material(), shader_names->albedo_texture_size,
+				Vector2i(p_texture->get_width(), p_texture->get_height()));
+	}
 	_change_notify();
 	_queue_shader_change();
 }
@@ -1605,10 +1676,34 @@ void BaseMaterial3D::_validate_property(PropertyInfo &property) const {
 		property.usage = 0;
 	}
 
+	// you can only enable anti-aliasing (in mataerials) on alpha scissor and alpha hash
+	const bool can_select_aa = (transparency == TRANSPARENCY_ALPHA_SCISSOR || transparency == TRANSPARENCY_ALPHA_HASH);
+	// alpha anti aliasiasing is only enabled when you can select aa
+	const bool alpha_aa_enabled = (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF) && can_select_aa;
+
+	// alpha scissor slider isn't needed when alpha antialiasing is enabled
 	if (property.name == "alpha_scissor_threshold" && transparency != TRANSPARENCY_ALPHA_SCISSOR) {
 		property.usage = 0;
 	}
 
+	// alpha hash scale slider is only needed if transparency is alpha hash
+	if (property.name == "alpha_hash_scale" && transparency != TRANSPARENCY_ALPHA_HASH) {
+		property.usage = 0;
+	}
+
+	if (property.name == "alpha_antialiasing_mode" && !can_select_aa) {
+		property.usage = 0;
+	}
+
+	// we cant choose an antialiasing mode if alpha isnt possible
+	if (property.name == "alpha_antialiasing_edge" && !alpha_aa_enabled) {
+		property.usage = 0;
+	}
+
+	if (property.name == "blend_mode" && alpha_aa_enabled) {
+		property.usage = 0;
+	}
+
 	if ((property.name == "heightmap_min_layers" || property.name == "heightmap_max_layers") && !deep_parallax) {
 		property.usage = 0;
 	}
@@ -1845,6 +1940,24 @@ float BaseMaterial3D::get_alpha_scissor_threshold() const {
 	return alpha_scissor_threshold;
 }
 
+void BaseMaterial3D::set_alpha_hash_scale(float p_scale) {
+	alpha_hash_scale = p_scale;
+	RS::get_singleton()->material_set_param(_get_material(), shader_names->alpha_hash_scale, p_scale);
+}
+
+float BaseMaterial3D::get_alpha_hash_scale() const {
+	return alpha_hash_scale;
+}
+
+void BaseMaterial3D::set_alpha_antialiasing_edge(float p_edge) {
+	alpha_antialiasing_edge = p_edge;
+	RS::get_singleton()->material_set_param(_get_material(), shader_names->alpha_antialiasing_edge, p_edge);
+}
+
+float BaseMaterial3D::get_alpha_antialiasing_edge() const {
+	return alpha_antialiasing_edge;
+}
+
 void BaseMaterial3D::set_grow(float p_grow) {
 	grow = p_grow;
 	RS::get_singleton()->material_set_param(_get_material(), shader_names->grow, p_grow);
@@ -2033,6 +2146,12 @@ void BaseMaterial3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_transparency", "transparency"), &BaseMaterial3D::set_transparency);
 	ClassDB::bind_method(D_METHOD("get_transparency"), &BaseMaterial3D::get_transparency);
 
+	ClassDB::bind_method(D_METHOD("set_alpha_antialiasing", "alpha_aa"), &BaseMaterial3D::set_alpha_antialiasing);
+	ClassDB::bind_method(D_METHOD("get_alpha_antialiasing"), &BaseMaterial3D::get_alpha_antialiasing);
+
+	ClassDB::bind_method(D_METHOD("set_alpha_antialiasing_edge", "edge"), &BaseMaterial3D::set_alpha_antialiasing_edge);
+	ClassDB::bind_method(D_METHOD("get_alpha_antialiasing_edge"), &BaseMaterial3D::get_alpha_antialiasing_edge);
+
 	ClassDB::bind_method(D_METHOD("set_shading_mode", "shading_mode"), &BaseMaterial3D::set_shading_mode);
 	ClassDB::bind_method(D_METHOD("get_shading_mode"), &BaseMaterial3D::get_shading_mode);
 
@@ -2186,6 +2305,9 @@ void BaseMaterial3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_alpha_scissor_threshold", "threshold"), &BaseMaterial3D::set_alpha_scissor_threshold);
 	ClassDB::bind_method(D_METHOD("get_alpha_scissor_threshold"), &BaseMaterial3D::get_alpha_scissor_threshold);
 
+	ClassDB::bind_method(D_METHOD("set_alpha_hash_scale", "threshold"), &BaseMaterial3D::set_alpha_hash_scale);
+	ClassDB::bind_method(D_METHOD("get_alpha_hash_scale"), &BaseMaterial3D::get_alpha_hash_scale);
+
 	ClassDB::bind_method(D_METHOD("set_grow_enabled", "enable"), &BaseMaterial3D::set_grow_enabled);
 	ClassDB::bind_method(D_METHOD("is_grow_enabled"), &BaseMaterial3D::is_grow_enabled);
 
@@ -2217,8 +2339,11 @@ void BaseMaterial3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_distance_fade_min_distance"), &BaseMaterial3D::get_distance_fade_min_distance);
 
 	ADD_GROUP("Transparency", "");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "transparency", PROPERTY_HINT_ENUM, "Disabled,Alpha,AlphaScissor,DepthPrePass"), "set_transparency", "get_transparency");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "transparency", PROPERTY_HINT_ENUM, "Disabled,Alpha,Alpha Scissor,Alpha Hash,Depth PrePass"), "set_transparency", "get_transparency");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_scissor_threshold", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_alpha_scissor_threshold", "get_alpha_scissor_threshold");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_hash_scale", PROPERTY_HINT_RANGE, "0,2,0.01"), "set_alpha_hash_scale", "get_alpha_hash_scale");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "alpha_antialiasing_mode", PROPERTY_HINT_ENUM, "Disabled,Alpha Edge Blend,Alpha Edge Clip"), "set_alpha_antialiasing", "get_alpha_antialiasing");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_antialiasing_edge", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_alpha_antialiasing_edge", "get_alpha_antialiasing_edge");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "blend_mode", PROPERTY_HINT_ENUM, "Mix,Add,Sub,Mul"), "set_blend_mode", "get_blend_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "cull_mode", PROPERTY_HINT_ENUM, "Back,Front,Disabled"), "set_cull_mode", "get_cull_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "depth_draw_mode", PROPERTY_HINT_ENUM, "Opaque Only,Always,Never"), "set_depth_draw_mode", "get_depth_draw_mode");
@@ -2414,6 +2539,7 @@ void BaseMaterial3D::_bind_methods() {
 	BIND_ENUM_CONSTANT(TRANSPARENCY_DISABLED);
 	BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA);
 	BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_SCISSOR);
+	BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_HASH);
 	BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
 	BIND_ENUM_CONSTANT(TRANSPARENCY_MAX);
 
@@ -2441,6 +2567,10 @@ void BaseMaterial3D::_bind_methods() {
 	BIND_ENUM_CONSTANT(BLEND_MODE_SUB);
 	BIND_ENUM_CONSTANT(BLEND_MODE_MUL);
 
+	BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_OFF);
+	BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE);
+	BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE);
+
 	BIND_ENUM_CONSTANT(DEPTH_DRAW_OPAQUE_ONLY);
 	BIND_ENUM_CONSTANT(DEPTH_DRAW_ALWAYS);
 	BIND_ENUM_CONSTANT(DEPTH_DRAW_DISABLED);
@@ -2506,7 +2636,6 @@ BaseMaterial3D::BaseMaterial3D(bool p_orm) :
 		element(this) {
 	orm = p_orm;
 	// Initialize to the same values as the shader
-	transparency = TRANSPARENCY_DISABLED;
 	shading_mode = SHADING_MODE_PER_PIXEL;
 	set_albedo(Color(1.0, 1.0, 1.0, 1.0));
 	set_specular(0.5);
@@ -2539,9 +2668,14 @@ BaseMaterial3D::BaseMaterial3D(bool p_orm) :
 	set_particles_anim_h_frames(1);
 	set_particles_anim_v_frames(1);
 	set_particles_anim_loop(false);
-	set_alpha_scissor_threshold(0.98);
 	emission_op = EMISSION_OP_ADD;
 
+	set_transparency(TRANSPARENCY_DISABLED);
+	set_alpha_antialiasing(ALPHA_ANTIALIASING_OFF);
+	set_alpha_scissor_threshold(0.05);
+	set_alpha_hash_scale(1.0);
+	set_alpha_antialiasing_edge(0.3);
+
 	proximity_fade_enabled = false;
 	distance_fade = DISTANCE_FADE_DISABLED;
 	set_proximity_fade_distance(1);
@@ -2582,10 +2716,8 @@ BaseMaterial3D::BaseMaterial3D(bool p_orm) :
 		features[i] = false;
 	}
 
-	current_key.key0 = 0;
-	current_key.key1 = 0;
-	current_key.invalid_key = 1;
 	texture_filter = TEXTURE_FILTER_LINEAR_WITH_MIPMAPS;
+
 	_queue_shader_change();
 }
 
@@ -2633,6 +2765,12 @@ bool StandardMaterial3D::_set(const StringName &p_name, const Variant &p_value)
 			set_transparency(TRANSPARENCY_ALPHA_SCISSOR);
 		}
 		return true;
+	} else if (p_name == "params_use_alpha_hash") {
+		bool use_hash = p_value;
+		if (use_hash) {
+			set_transparency(TRANSPARENCY_ALPHA_HASH);
+		}
+		return true;
 	} else if (p_name == "params_depth_draw_mode") {
 		int mode = p_value;
 		if (mode == 3) {
@@ -2667,6 +2805,8 @@ bool StandardMaterial3D::_set(const StringName &p_name, const Variant &p_value)
 			{ "params_grow", "grow" },
 			{ "params_grow_amount", "grow_amount" },
 			{ "params_alpha_scissor_threshold", "alpha_scissor_threshold" },
+			{ "params_alpha_hash_scale", "alpha_hash_scale" },
+			{ "params_alpha_antialiasing_edge", "alpha_antialiasing_edge" },
 
 			{ "depth_scale", "heightmap_scale" },
 			{ "depth_deep_parallax", "heightmap_deep_parallax" },
diff --git a/scene/resources/material.h b/scene/resources/material.h
index b5bdd77eb5..da1808d348 100644
--- a/scene/resources/material.h
+++ b/scene/resources/material.h
@@ -145,17 +145,26 @@ public:
 
 	enum DetailUV {
 		DETAIL_UV_1,
-		DETAIL_UV_2
+		DETAIL_UV_2,
+		DETAIL_UV_MAX
 	};
 
 	enum Transparency {
 		TRANSPARENCY_DISABLED,
 		TRANSPARENCY_ALPHA,
 		TRANSPARENCY_ALPHA_SCISSOR,
+		TRANSPARENCY_ALPHA_HASH,
 		TRANSPARENCY_ALPHA_DEPTH_PRE_PASS,
 		TRANSPARENCY_MAX,
 	};
 
+	enum AlphaAntiAliasing {
+		ALPHA_ANTIALIASING_OFF,
+		ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE,
+		ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE,
+		ALPHA_ANTIALIASING_MAX
+	};
+
 	enum ShadingMode {
 		SHADING_MODE_UNSHADED,
 		SHADING_MODE_PER_PIXEL,
@@ -184,18 +193,21 @@ public:
 		BLEND_MODE_ADD,
 		BLEND_MODE_SUB,
 		BLEND_MODE_MUL,
+		BLEND_MODE_MAX
 	};
 
 	enum DepthDrawMode {
 		DEPTH_DRAW_OPAQUE_ONLY,
 		DEPTH_DRAW_ALWAYS,
 		DEPTH_DRAW_DISABLED,
+		DEPTH_DRAW_MAX
 	};
 
 	enum CullMode {
 		CULL_BACK,
 		CULL_FRONT,
-		CULL_DISABLED
+		CULL_DISABLED,
+		CULL_MAX
 	};
 
 	enum Flags {
@@ -227,6 +239,7 @@ public:
 		DIFFUSE_LAMBERT_WRAP,
 		DIFFUSE_OREN_NAYAR,
 		DIFFUSE_TOON,
+		DIFFUSE_MAX
 	};
 
 	enum SpecularMode {
@@ -235,6 +248,7 @@ public:
 		SPECULAR_PHONG,
 		SPECULAR_TOON,
 		SPECULAR_DISABLED,
+		SPECULAR_MAX
 	};
 
 	enum BillboardMode {
@@ -242,6 +256,7 @@ public:
 		BILLBOARD_ENABLED,
 		BILLBOARD_FIXED_Y,
 		BILLBOARD_PARTICLES,
+		BILLBOARD_MAX
 	};
 
 	enum TextureChannel {
@@ -249,12 +264,14 @@ public:
 		TEXTURE_CHANNEL_GREEN,
 		TEXTURE_CHANNEL_BLUE,
 		TEXTURE_CHANNEL_ALPHA,
-		TEXTURE_CHANNEL_GRAYSCALE
+		TEXTURE_CHANNEL_GRAYSCALE,
+		TEXTURE_CHANNEL_MAX
 	};
 
 	enum EmissionOperator {
 		EMISSION_OP_ADD,
-		EMISSION_OP_MULTIPLY
+		EMISSION_OP_MULTIPLY,
+		EMISSION_OP_MAX
 	};
 
 	enum DistanceFadeMode {
@@ -262,43 +279,47 @@ public:
 		DISTANCE_FADE_PIXEL_ALPHA,
 		DISTANCE_FADE_PIXEL_DITHER,
 		DISTANCE_FADE_OBJECT_DITHER,
+		DISTANCE_FADE_MAX
 	};
 
 private:
-	union MaterialKey {
-		struct {
-			uint64_t feature_mask : FEATURE_MAX;
-			uint64_t detail_uv : 1;
-			uint64_t blend_mode : 2;
-			uint64_t depth_draw_mode : 2;
-			uint64_t cull_mode : 2;
-			uint64_t flags : FLAG_MAX;
-			uint64_t detail_blend_mode : 2;
-			uint64_t diffuse_mode : 3;
-			uint64_t specular_mode : 3;
-			uint64_t invalid_key : 1;
-			uint64_t deep_parallax : 1;
-			uint64_t billboard_mode : 2;
-			uint64_t grow : 1;
-			uint64_t proximity_fade : 1;
-			uint64_t distance_fade : 2;
-			uint64_t emission_op : 1;
-			uint64_t texture_filter : 3;
-			uint64_t transparency : 2;
-			uint64_t shading_mode : 2;
-			uint64_t roughness_channel : 3;
-		};
-
-		struct {
-			uint64_t key0;
-			uint64_t key1;
-		};
+	struct MaterialKey {
+		// enum values
+		uint64_t texture_filter : get_num_bits(TEXTURE_FILTER_MAX - 1);
+		uint64_t detail_uv : get_num_bits(DETAIL_UV_MAX - 1);
+		uint64_t transparency : get_num_bits(TRANSPARENCY_MAX - 1);
+		uint64_t alpha_antialiasing_mode : get_num_bits(ALPHA_ANTIALIASING_MAX - 1);
+		uint64_t shading_mode : get_num_bits(SHADING_MODE_MAX - 1);
+		uint64_t blend_mode : get_num_bits(BLEND_MODE_MAX - 1);
+		uint64_t depth_draw_mode : get_num_bits(DEPTH_DRAW_MAX - 1);
+		uint64_t cull_mode : get_num_bits(CULL_MAX - 1);
+		uint64_t diffuse_mode : get_num_bits(DIFFUSE_MAX - 1);
+		uint64_t specular_mode : get_num_bits(SPECULAR_MAX - 1);
+		uint64_t billboard_mode : get_num_bits(BILLBOARD_MAX - 1);
+		uint64_t detail_blend_mode : get_num_bits(BLEND_MODE_MAX - 1);
+		uint64_t roughness_channel : get_num_bits(TEXTURE_CHANNEL_MAX - 1);
+		uint64_t emission_op : get_num_bits(EMISSION_OP_MAX - 1);
+		uint64_t distance_fade : get_num_bits(DISTANCE_FADE_MAX - 1);
+
+		// flag bitfield
+		uint64_t feature_mask : FEATURE_MAX - 1;
+		uint64_t flags : FLAG_MAX - 1;
+
+		// booleans
+		uint64_t deep_parallax : 1;
+		uint64_t grow : 1;
+		uint64_t proximity_fade : 1;
+
+		MaterialKey() {
+			memset(this, 0, sizeof(MaterialKey));
+		}
 
 		bool operator==(const MaterialKey &p_key) const {
-			return (key0 == p_key.key0) && (key1 == p_key.key1);
+			return memcmp(this, &p_key, sizeof(MaterialKey)) == 0;
 		}
+
 		bool operator<(const MaterialKey &p_key) const {
-			return (key0 == p_key.key0) ? (key1 < p_key.key1) : (key0 < p_key.key0);
+			return memcmp(this, &p_key, sizeof(MaterialKey)) < 0;
 		}
 	};
 
@@ -313,13 +334,7 @@ private:
 
 	_FORCE_INLINE_ MaterialKey _compute_key() const {
 		MaterialKey mk;
-		mk.key0 = 0;
-		mk.key1 = 0;
-		for (int i = 0; i < FEATURE_MAX; i++) {
-			if (features[i]) {
-				mk.feature_mask |= ((uint64_t)1 << i);
-			}
-		}
+
 		mk.detail_uv = detail_uv;
 		mk.blend_mode = blend_mode;
 		mk.depth_draw_mode = depth_draw_mode;
@@ -328,20 +343,28 @@ private:
 		mk.transparency = transparency;
 		mk.shading_mode = shading_mode;
 		mk.roughness_channel = roughness_texture_channel;
-		for (int i = 0; i < FLAG_MAX; i++) {
-			if (flags[i]) {
-				mk.flags |= ((uint64_t)1 << i);
-			}
-		}
 		mk.detail_blend_mode = detail_blend_mode;
 		mk.diffuse_mode = diffuse_mode;
 		mk.specular_mode = specular_mode;
 		mk.billboard_mode = billboard_mode;
-		mk.deep_parallax = deep_parallax ? 1 : 0;
+		mk.deep_parallax = deep_parallax;
 		mk.grow = grow_enabled;
 		mk.proximity_fade = proximity_fade_enabled;
 		mk.distance_fade = distance_fade;
 		mk.emission_op = emission_op;
+		mk.alpha_antialiasing_mode = alpha_antialiasing_mode;
+
+		for (int i = 0; i < FEATURE_MAX; i++) {
+			if (features[i]) {
+				mk.feature_mask |= ((uint64_t)1 << i);
+			}
+		}
+
+		for (int i = 0; i < FLAG_MAX; i++) {
+			if (flags[i]) {
+				mk.flags |= ((uint64_t)1 << i);
+			}
+		}
 
 		return mk;
 	}
@@ -392,9 +415,14 @@ private:
 		StringName rim_texture_channel;
 		StringName heightmap_texture_channel;
 		StringName refraction_texture_channel;
-		StringName alpha_scissor_threshold;
 
 		StringName texture_names[TEXTURE_MAX];
+
+		StringName alpha_scissor_threshold;
+		StringName alpha_hash_scale;
+
+		StringName alpha_antialiasing_edge;
+		StringName albedo_texture_size;
 	};
 
 	static Mutex material_mutex;
@@ -433,6 +461,8 @@ private:
 	float refraction;
 	float point_size;
 	float alpha_scissor_threshold;
+	float alpha_hash_scale;
+	float alpha_antialiasing_edge;
 	bool grow_enabled;
 	float ao_light_affect;
 	float grow;
@@ -482,6 +512,8 @@ private:
 	TextureChannel ao_texture_channel;
 	TextureChannel refraction_texture_channel;
 
+	AlphaAntiAliasing alpha_antialiasing_mode;
+
 	bool features[FEATURE_MAX];
 
 	Ref<Texture2D> textures[TEXTURE_MAX];
@@ -584,6 +616,12 @@ public:
 	void set_transparency(Transparency p_transparency);
 	Transparency get_transparency() const;
 
+	void set_alpha_antialiasing(AlphaAntiAliasing p_alpha_aa);
+	AlphaAntiAliasing get_alpha_antialiasing() const;
+
+	void set_alpha_antialiasing_edge(float p_edge);
+	float get_alpha_antialiasing_edge() const;
+
 	void set_shading_mode(ShadingMode p_shading_mode);
 	ShadingMode get_shading_mode() const;
 
@@ -660,6 +698,9 @@ public:
 	void set_alpha_scissor_threshold(float p_threshold);
 	float get_alpha_scissor_threshold() const;
 
+	void set_alpha_hash_scale(float p_scale);
+	float get_alpha_hash_scale() const;
+
 	void set_on_top_of_alpha();
 
 	void set_proximity_fade(bool p_enable);
@@ -707,6 +748,7 @@ VARIANT_ENUM_CAST(BaseMaterial3D::TextureParam)
 VARIANT_ENUM_CAST(BaseMaterial3D::TextureFilter)
 VARIANT_ENUM_CAST(BaseMaterial3D::ShadingMode)
 VARIANT_ENUM_CAST(BaseMaterial3D::Transparency)
+VARIANT_ENUM_CAST(BaseMaterial3D::AlphaAntiAliasing)
 VARIANT_ENUM_CAST(BaseMaterial3D::DetailUV)
 VARIANT_ENUM_CAST(BaseMaterial3D::Feature)
 VARIANT_ENUM_CAST(BaseMaterial3D::BlendMode)