Refactor MaterialManager to support more options (like e3d submodel selfillum)

Author: marcinn

addons/libmaszyna/e3d/e3d_instancer.gd

@@ -43,6 +43,11 @@ func _is_submodel_valid(target_node: E3DModelInstance, submodel: E3DSubModel) ->
 
 func _get_material_override(target_node: E3DModelInstance, submodel: E3DSubModel) -> Material:
     var unprefixed_model_path: String = "/".join(target_node.data_path.split("/").slice(1))
+    var options = MaterialManager.MaterialOptions.new()
+
+    # TODO: handle more material options here (selfillum, diffuse_color, etc)
+    options.force_transparent = submodel.material_transparent
+
     if submodel.dynamic_material:
         if target_node.skins.size() < submodel.dynamic_material_index + 1:
             push_warning(
@@ -57,7 +62,7 @@ func _get_material_override(target_node: E3DModelInstance, submodel: E3DSubModel
             else MaterialManager.Transparency.Disabled
         )
         var skin: Variant = target_node.skins[submodel.dynamic_material_index]
-        return MaterialManager.get_material(unprefixed_model_path, skin, dynamic_transparency)
+        return MaterialManager.get_material(unprefixed_model_path, skin, options)
 
     if submodel.material_colored:
         return _colored_material
@@ -71,8 +76,7 @@ func _get_material_override(target_node: E3DModelInstance, submodel: E3DSubModel
         return MaterialManager.get_material(
             unprefixed_model_path,
             submodel.material_name,
-            named_transparency,
-            submodel.diffuse_color,
+            options,
         )
 
     return null

addons/libmaszyna/materials/material_factory.gd

@@ -81,8 +81,7 @@ func create(
     model_path: String = "",
     season: MaterialManager.Season = MaterialManager.Season.SEASON_SUMMER,
     weather: MaterialManager.Weather = MaterialManager.Weather.WEATHER_CLEAR,
-    force_transparent: bool = false,
-    diffuse_color: Color = Color.WHITE
+    options: MaterialManager.MaterialOptions = MaterialManager.MaterialOptions.new(),
 ) -> Material:
     var variant: MaszynaMaterial.MaszynaMaterialVariant = mmat.get_variant(season, weather)
     var shader_meta:MaszynaShaderMeta = _get_shader_meta(variant.shader)
@@ -94,8 +93,7 @@ func create(
         shader_meta,
         shader_meta.texture_map,
         model_path,
-        force_transparent,
-        diffuse_color,
+        options,
     )
     return material
 
@@ -106,8 +104,7 @@ func apply(
     model_path: String,
     season: MaterialManager.Season,
     weather: MaterialManager.Weather,
-    force_transparent: bool,
-    diffuse_color: Color = Color.WHITE
+    options: MaterialManager.MaterialOptions = MaterialManager.MaterialOptions.new(),
 ) -> void:
     var variant: MaszynaMaterial.MaszynaMaterialVariant = mmat.get_variant(season, weather)
     var shader_meta:MaszynaShaderMeta = _get_shader_meta(variant.shader)
@@ -118,8 +115,7 @@ func apply(
         shader_meta,
         shader_meta.texture_map,
         model_path,
-        force_transparent,
-        diffuse_color
+        options,
     )
 
 
@@ -138,8 +134,7 @@ func _apply(
     shader_meta: MaszynaShaderMeta,
     texture_map: TextureMap,
     model_path: String,
-    force_transparent: bool,
-    diffuse_color: Color,
+    options: MaterialManager.MaterialOptions,
 ) -> void:
 
     if not material is ShaderMaterial or not shader_meta.base_material is ShaderMaterial:
@@ -151,9 +146,9 @@ 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, diffuse_color)
+    shader_meta.factory.call(mmat, variant, material, texture_map, model_path, options.diffuse_color)
     var transparency: MaterialManager.Transparency = MaterialManager.Transparency.Disabled
-    if mmat.transparent or force_transparent:
+    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)

addons/libmaszyna/materials/material_manager.gd

@@ -12,11 +12,15 @@ var _managed_materials: Dictionary = {}
 
 enum Transparency { Disabled, Alpha, AlphaScissor }
 
-const _transparency_codes = {
-    Transparency.Disabled: "0",
-    Transparency.Alpha: "a",
-    Transparency.AlphaScissor: "s",
-}
+
+class MaterialOptions:
+    var diffuse_color: Color = Color.WHITE
+    var selfillum_color: Color = Color.WHITE
+    var selfillum_energy: float = 1.0
+    var selfillum_enabled: bool = false
+    var force_transparent: bool = false   # TODO: AphaCut/Alpha modes support
+    var alpha_scissor_threshold: float = 0.5
+
 
 @export var season: Season = Season.SEASON_SUMMER:
     set(x):
@@ -41,31 +45,29 @@ func load_material(model_path:String, material_name:String) -> MaszynaMaterial:
 func get_material(
     model_path:String,
     material_path:String,
-    transparent:Transparency = Transparency.Disabled,
-    diffuse_color: Color = Color(1.0, 1.0, 1.0)
+    options: MaterialOptions = MaterialOptions.new(),
 ) -> Material:
-    var cache_hash: String = _compute_cache_hash(model_path, material_path, transparent, diffuse_color)
+    var cache_hash: String = _compute_cache_hash(model_path, material_path, options)
     var managed_material: Dictionary = _managed_materials.get(cache_hash, {})
     if managed_material:
         var material_ref: WeakRef = managed_material.get("material_ref") as WeakRef
         var material: ShaderMaterial = material_ref.get_ref() as ShaderMaterial if material_ref else null
         if material:
             return material
         _managed_materials.erase(cache_hash)
-    var force_transparent := not transparent == Transparency.Disabled  # TODO: ALPHA
+    var force_transparent = options.force_transparent  # TODO: ALPHA
     var output: ShaderMaterial = _materials_cache.get(cache_hash) as ShaderMaterial
     if not output:
         var mmat: MaszynaMaterial = load_material(model_path, material_path)
-        output = MaterialFactory.create(mmat, model_path, season, weather, force_transparent, diffuse_color)
+        output = MaterialFactory.create(mmat, model_path, season, weather, options)
     else:
         var mmat: MaszynaMaterial = load_material(model_path, material_path)
-        MaterialFactory.apply(output, mmat, model_path, season, weather, force_transparent, diffuse_color)
+        MaterialFactory.apply(output, mmat, model_path, season, weather, options)
     _managed_materials[cache_hash] = {
         "material_ref": weakref(output),
         "model_path": model_path,
         "material_path": material_path,
-        "force_transparent": force_transparent,
-        "diffuse_color": diffuse_color,
+        "options": options,
     }
     _materials_cache.set(cache_hash, output)
     return output
@@ -107,14 +109,18 @@ func load_texture(model_path:String, material_name:String, normal:bool = false)
 func _compute_cache_hash(
     model_path: String,
     material_path: String,
-    transparent: Transparency,
-    diffuse_color: Color,
+    options: MaterialOptions,
 ) -> String:
-    return model_path.path_join(("%s_t%s_%s.res" % [
-        material_path,
-        _transparency_codes[transparent],
-        "%x%x%x" % [diffuse_color.r8, diffuse_color.g8, diffuse_color.b8],
-    ]))
+    var options_hash = ":".join([
+        options.force_transparent,
+        options.diffuse_color.to_html(true),
+        options.alpha_scissor_threshold,
+        options.selfillum_enabled,
+        options.selfillum_color.to_html(true),
+        options.selfillum_energy,
+    ].map(str)).md5_text()
+    return model_path.path_join("%s_%s.res" % [material_path, options_hash])
+
 
 func _refresh_managed_materials() -> void:
     var cache_hashes: Array = _managed_materials.keys()
@@ -134,7 +140,8 @@ func _refresh_managed_material(cache_hash: String) -> void:
     var material_path: String = managed_material.get("material_path", "")
     var force_transparent: Transparency = managed_material.get("force_transparent", false)
     var diffuse_color: Color = managed_material.get("diffuse_color", Color.WHITE)
+    var options:MaterialOptions = managed_material.get("options")
     var mmat: MaszynaMaterial = load_material(model_path, material_path)
     mmat.transparent = mmat.transparent or force_transparent
-    MaterialFactory.apply(material, mmat, model_path, season, weather, force_transparent, diffuse_color)
+    MaterialFactory.apply(material, mmat, model_path, season, weather, options)
     _materials_cache.set(cache_hash, material)