add emission

Author: marcinn

addons/libmaszyna/e3d/e3d_instancer.gd

@@ -47,6 +47,9 @@ func _get_material_override(target_node: E3DModelInstance, submodel: E3DSubModel
 
     # TODO: handle more material options here (selfillum, diffuse_color, etc)
     options.force_transparent = submodel.material_transparent
+    options.selfillum_energy = options.selfillum_color.a  # legacy renderer
+    options.selfillum_color = submodel.self_illumination
+    options.selfillum_enabled = options.selfillum_energy > 0.0 and submodel.lights_on_threshold >= 1.0  # legacy renderer logic
 
     if submodel.dynamic_material:
         if target_node.skins.size() < submodel.dynamic_material_index + 1:

addons/libmaszyna/materials/material_factory.gd

@@ -146,12 +146,15 @@ func _apply(
         if property_name == "shader" or property_name == "render_priority" or property_name.begins_with("shader_parameter/"):
             target_shader_material.set(property_name, source_shader_material.get(property_name))
 
-    shader_meta.factory.call(mmat, variant, material, texture_map, model_path, options.diffuse_color)
+    shader_meta.factory.call(mmat, variant, material, texture_map, model_path, options)
     var transparency: MaterialManager.Transparency = MaterialManager.Transparency.Disabled
     if mmat.transparent or options.force_transparent:
         transparency = MaterialManager.Transparency.AlphaScissor
     target_shader_material.set_shader_parameter("transparency", transparency)
     target_shader_material.set_shader_parameter("alpha_scissor_threshold", 0.5)
+    target_shader_material.set_shader_parameter("emission_enabled", options.selfillum_enabled)
+    target_shader_material.set_shader_parameter("emission_color", options.selfillum_color if options.selfillum_color else Color(1.0, 1.0, 1.0, 1.0))
+    target_shader_material.set_shader_parameter("emission_energy", options.selfillum_energy)
 
 
 func _apply_default_material(
@@ -160,7 +163,7 @@ func _apply_default_material(
     material: ShaderMaterial,
     texture_map: TextureMap,
     model_path: String,
-    diffuse_color: Color,
+    options: MaterialManager.MaterialOptions,
 ) -> void:
     var diffuse_texture: String = variant.get_texture_path(texture_map.albedo)
     var normalmap_texture: String = variant.get_texture_path(texture_map.normalmap)
@@ -178,7 +181,7 @@ func _apply_default_material(
                 1.0
             ))
     else:
-        material.set_shader_parameter("albedo", diffuse_color)
+        material.set_shader_parameter("albedo", options.diffuse_color)
 
     if normalmap_texture:
         material.set_shader_parameter("texture_normal", MaterialManager.load_texture(model_path, normalmap_texture, true))
@@ -192,14 +195,17 @@ func _apply_default_material(
 
     if variant.has_parameter("reflection"):
         material.set_shader_parameter("metallic", variant.get_parameter("reflection"))
+    material.set_shader_parameter("emission_enabled", options.selfillum_enabled)
+    material.set_shader_parameter("emission_color", options.selfillum_color)
+    material.set_shader_parameter("emission_energy", options.selfillum_energy)
 
 func _apply_parallax(
     mmat: MaszynaMaterial,
     variant: MaszynaMaterial.MaszynaMaterialVariant,
     material: ShaderMaterial,
     texture_map: TextureMap,
     model_path: String,
-    diffuse_color: Color,
+    options: MaterialManager.MaterialOptions,
 ) -> void:
     var diffuse_texture_path: String = variant.get_texture_path(texture_map.albedo)
     var normalmap_texture_path: String = variant.get_texture_path(texture_map.normalmap)
@@ -223,7 +229,7 @@ func _apply_parallax(
 
     var albedo_multiplier:Color = Color(1.0, 1.0, 1.0, 1.0)
     if not diffuse_texture_path:
-        albedo_multiplier = diffuse_color
+        albedo_multiplier = options.diffuse_color
 
     if variant.has_parameter("diffuse"):
         albedo_multiplier = Color(
@@ -262,7 +268,7 @@ func _apply_water(
     material: ShaderMaterial,
     texture_map: TextureMap,
     model_path: String,
-    diffuse_color: Color,
+    options: MaterialManager.MaterialOptions,
 ) -> void:
     var diffuse_texture_path: String = variant.get_texture_path(texture_map.albedo)
     var normalmap_texture_path: String = variant.get_texture_path(texture_map.normalmap)

addons/libmaszyna/materials/types/default.gdshader

@@ -21,6 +21,10 @@ uniform float metallic : hint_range(0.0, 1.0, 0.01);
 uniform sampler2D texture_normal : hint_roughness_normal, filter_linear_mipmap, repeat_enable;
 uniform float normal_scale : hint_range(-16.0, 16.0);
 
+uniform bool emission_enabled = false;
+uniform vec4 emission_color;
+uniform float emission_energy : hint_range(0.0, 16.0);
+
 uniform vec3 uv1_scale;
 uniform vec3 uv1_offset;
 uniform vec3 uv2_scale;
@@ -50,4 +54,9 @@ void fragment() {
 	// Normal Map: Enabled
 	NORMAL_MAP = texture(texture_normal, base_uv).rgb;
 	NORMAL_MAP_DEPTH = normal_scale;
+
+    if(emission_enabled) {
+        EMISSION = emission_color.rgb * albedo_tex.rgb * emission_energy;
+    }
+
 }

addons/libmaszyna/materials/types/normalmap.gdshader

@@ -21,6 +21,10 @@ uniform float metallic : hint_range(0.0, 1.0, 0.01);
 uniform sampler2D texture_normal : hint_roughness_normal, filter_linear_mipmap, repeat_enable;
 uniform float normal_scale : hint_range(-16.0, 16.0);
 
+uniform bool emission_enabled = false;
+uniform vec4 emission_color;
+uniform float emission_energy : hint_range(0.0, 16.0);
+
 uniform vec3 uv1_scale;
 uniform vec3 uv1_offset;
 uniform vec3 uv2_scale;
@@ -50,4 +54,10 @@ void fragment() {
 	// Normal Map: Enabled
 	NORMAL_MAP = texture(texture_normal, base_uv).rgb;
 	NORMAL_MAP_DEPTH = normal_scale;
+
+    if(emission_enabled) {
+        EMISSION = emission_color.rgb * albedo_tex.rgb * emission_energy;
+    }
+
+
 }

addons/libmaszyna/materials/types/normalmap_specgloss.gdshader

@@ -21,6 +21,10 @@ uniform float metallic : hint_range(0.0, 1.0, 0.01);
 uniform sampler2D texture_normal : hint_roughness_normal, filter_linear_mipmap, repeat_enable;
 uniform float normal_scale : hint_range(-16.0, 16.0);
 
+uniform bool emission_enabled = false;
+uniform vec4 emission_color;
+uniform float emission_energy : hint_range(0.0, 16.0);
+
 uniform vec3 uv1_scale;
 uniform vec3 uv1_offset;
 uniform vec3 uv2_scale;
@@ -50,4 +54,10 @@ void fragment() {
 	// Normal Map: Enabled
 	NORMAL_MAP = texture(texture_normal, base_uv).rgb;
 	NORMAL_MAP_DEPTH = normal_scale;
+
+    if(emission_enabled) {
+        EMISSION = emission_color.rgb * albedo_tex.rgb * emission_energy;
+    }
+
+
 }

addons/libmaszyna/materials/types/parallax.gdshader

@@ -149,5 +149,6 @@ void fragment() {
 
         NORMAL_MAP = decode_normal_from_rg(normal_sample);
         NORMAL_MAP_DEPTH = 1.0;
+
     }
 }

addons/libmaszyna/materials/types/shadowlessnormalmap.gdshader

@@ -18,6 +18,11 @@ uniform sampler2D texture_roughness : hint_roughness_r, filter_linear_mipmap, re
 uniform float specular : hint_range(0.0, 1.0, 0.01);
 uniform float metallic : hint_range(0.0, 1.0, 0.01);
 
+uniform bool emission_enabled = false;
+uniform vec4 emission_color;
+uniform float emission_energy : hint_range(0.0, 16.0);
+
+
 uniform vec3 uv1_scale;
 uniform vec3 uv1_offset;
 uniform vec3 uv2_scale;
@@ -43,4 +48,10 @@ void fragment() {
 	vec4 roughness_texture_channel = vec4(1.0, 0.0, 0.0, 0.0);
 	float roughness_tex = dot(texture(texture_roughness, base_uv), roughness_texture_channel);
 	ROUGHNESS = roughness_tex * roughness;
+
+    if(emission_enabled) {
+        EMISSION = emission_color.rgb * albedo_tex.rgb * emission_energy;
+    }
+
+
 }

addons/libmaszyna/materials/types/sunlessnormalmap.gdshader

@@ -21,6 +21,11 @@ uniform float metallic : hint_range(0.0, 1.0, 0.01);
 uniform sampler2D texture_normal : hint_roughness_normal, filter_linear_mipmap, repeat_enable;
 uniform float normal_scale : hint_range(-16.0, 16.0);
 
+uniform bool emission_enabled = false;
+uniform vec4 emission_color;
+uniform float emission_energy : hint_range(0.0, 16.0);
+
+
 uniform vec3 uv1_scale;
 uniform vec3 uv1_offset;
 uniform vec3 uv2_scale;
@@ -50,4 +55,10 @@ void fragment() {
 	// Normal Map: Enabled
 	NORMAL_MAP = texture(texture_normal, base_uv).rgb;
 	NORMAL_MAP_DEPTH = normal_scale;
+
+    if(emission_enabled) {
+        EMISSION = emission_color.rgb * albedo_tex.rgb * emission_energy;
+    }
+
+
 }

demo/demo_3d.tscn

@@ -53,9 +53,9 @@ glow_enabled = true
 fog_enabled = true
 fog_sky_affect = 0.4
 volumetric_fog_enabled = true
-volumetric_fog_density = 0.01
+volumetric_fog_density = 0.003
 volumetric_fog_anisotropy = 0.0
-volumetric_fog_length = 55.89
+volumetric_fog_length = 6.5
 volumetric_fog_detail_spread = 1.0
 volumetric_fog_sky_affect = 0.405
 adjustment_enabled = true
@@ -233,8 +233,6 @@ visible = null
 [node name="MaszynaEnvironmentNode" type="Node" parent="." unique_id=1464463242]
 script = ExtResource("2_py6pt")
 world_environment = NodePath("../WorldEnvironment")
-season = 2
-weather = 0
 sky_texture_offset = Vector2(0.49, 0.005)
 sky_texture_scale = Vector2(0.547, 0.865)
 sky_energy = 0.85
@@ -250,9 +248,8 @@ size = Vector3(5000, 0.1, 5000)
 
 [node name="DirectionalLight3D" type="DirectionalLight3D" parent="." unique_id=786641912]
 transform = Transform3D(-0.846557, 0.01871, 0.531969, 0.393589, 0.694835, 0.601906, -0.358369, 0.718925, -0.595582, 5.83027, -6.14961, 0)
-visible = false
 light_color = Color(0.929688, 0.848771, 0.817108, 1)
-light_energy = 1.12
+light_energy = 1.2
 light_indirect_energy = 2.0
 light_volumetric_fog_energy = 11.811
 shadow_enabled = true

src/parsers/e3d_parser.cpp

@@ -89,8 +89,9 @@ namespace godot {
         result.first_vertex_idx = u32s(p_file->get_32());
         result.material_idx = u32s(p_file->get_32());
         result.is_material_colored = (result.material_idx == 0);
-        result.lights_on_threshold = p_file->get_float();
-        result.visibility_light_threshold = p_file->get_float();
+        p_file->get_float();                              // offset 40 UNUSED
+        result.lights_on_threshold = p_file->get_float(); // offset 44
+        // result.visibility_light_threshold = p_file->get_float();
         // ReSharper disable once CppExpressionWithoutSideEffects
         p_file->get_buffer(16); // skip unused RGBA ambient
         const float diffuse_r = p_file->get_float();