Detect and export alpha cutoff in Blender

[libs/gl.git] / blender / io_mspgl / export_material.py

diff --git a/blender/io_mspgl/export_material.py b/blender/io_mspgl/export_material.py
index b0df347f7fb0a2af9f07014e16a60bd2023afae8..36dbdc690696346b544e2e367518859df60da693 100644 (file)
--- a/blender/io_mspgl/export_material.py
+++ b/blender/io_mspgl/export_material.py
@@ -1,3 +1,31 @@
+def create_shadow_method(tech_res, material, resources, detail):
+       from .datafile import Statement
+
+       color_prop = next((p for p in material.properties if p.keyword and "color" in p.keyword), None)
+
+       st = Statement("method", "shadow"+detail)
+       if material.alpha_cutoff>0.0 and color_prop and 'A' in color_prop.tex_channels:
+               st.sub.append(tech_res.create_reference_statement("shader", resources["occluder{}_masked.shader".format(detail)]))
+               ss = Statement("texture", "alpha_map")
+
+               from .export_texture import TextureExporter
+               from .export_texture import SamplerExporter
+               texture_export = TextureExporter()
+               sampler_export = SamplerExporter()
+
+               tex_res = resources[texture_export.get_texture_name(color_prop.texture, color_prop.tex_channels)]
+               ss.sub.append(tech_res.create_reference_statement("texture", tex_res))
+               ss.sub.append(tech_res.create_reference_statement("sampler", resources[sampler_export.get_sampler_name(color_prop.texture)]))
+               st.sub.append(ss)
+
+               ss = Statement("uniforms")
+               ss.sub.append(Statement("uniform", "alpha_cutoff", material.alpha_cutoff))
+               st.sub.append(ss)
+       else:
+               st.sub.append(Statement("shader", "occluder{}.glsl.shader".format(detail)))
+
+       return st;
+
 def create_technique_resource(material, resources):
        from .datafile import Resource, Statement, Token
        tech_res = Resource(material.name+".tech", "technique")
@@ -49,13 +77,8 @@ def create_technique_resource(material, resources):
                tech_res.statements.append(st)
 
                if material.cast_shadows:
-                       st = Statement("method", "shadow")
-                       st.sub.append(Statement("shader", "occluder.glsl.shader"))
-                       tech_res.statements.append(st)
-
-                       st = Statement("method", "shadow_thsm")
-                       st.sub.append(Statement("shader", "occluder_thsm.glsl.shader"))
-                       tech_res.statements.append(st)
+                       tech_res.statements.append(create_shadow_method(tech_res, material, resources, ""));
+                       tech_res.statements.append(create_shadow_method(tech_res, material, resources, "_thsm"));
 
        return tech_res
 
@@ -91,6 +114,12 @@ class MaterialExporter:
                        else:
                                resources[mat_name] = None
 
+               if material.cast_shadows and material.alpha_cutoff>0.0:
+                       for detail in ("", "_thsm"):
+                               shader_name = "occluder{}_masked.shader".format(detail)
+                               if shader_name not in resources:
+                                       resources[shader_name] = self.export_shader(shader_name, "occluder{}.glsl".format(detail), {"use_alpha_cutoff":True}, resources)
+
        def export_technique(self, material, resources):
                from .material import Material
                if type(material)!=Material:
@@ -115,6 +144,8 @@ class MaterialExporter:
                        from .export_texture import SamplerExporter
                        sampler_export = SamplerExporter()
                        mat_res.statements.append(mat_res.create_reference_statement("sampler", resources[sampler_export.get_sampler_name(textures[0])]))
+               if material.alpha_cutoff>0.0:
+                       mat_res.statements.append(Statement("alpha_cutoff", material.alpha_cutoff))
 
                return mat_res
 
@@ -132,6 +163,17 @@ class MaterialExporter:
                else:
                        return Statement(prop.keyword, prop.value)
 
+       def export_shader(self, name, module, spec_values, resources):
+               from .datafile import Resource, Statement
+               shader_res = Resource(name, "shader")
+
+               st = Statement("module", module)
+               for k, v in spec_values.items():
+                       st.sub.append(Statement("specialize", k, v))
+               shader_res.statements.append(st)
+
+               return shader_res
+
 
 class MaterialAtlasExporter:
        def __init__(self):