Refactor face cull settings 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 ffdae1cc7f782cd65ffc2781178e389f3a11fec7..aceb6cc0d833ccfb2ab186ff4f4eb017f09cca5c 100644 (file)
--- a/blender/io_mspgl/export_material.py
+++ b/blender/io_mspgl/export_material.py
@@ -1,4 +1,33 @@
-import os
+def create_shadow_method(tech_res, material, resources, detail):
+       from .datafile import Statement, Token
+
+       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)))
+
+       if material.face_cull=='BACK':
+               st.sub.append(Statement("face_cull", Token("CULL_BACK")))
+
+       return st;
 
 def create_technique_resource(material, resources):
        from .datafile import Resource, Statement, Token
@@ -34,6 +63,9 @@ def create_technique_resource(material, resources):
                                        ss.sub.append(Statement("uniform", u.name, *u.values[:u.size]))
                                st.sub.append(ss)
 
+                       if material.face_cull=='BACK':
+                               st.sub.append(Statement("face_cull", Token("CULL_BACK")))
+
                        tech_res.statements.append(st)
        else:
                base_method = "blended" if material.blend_type!='NONE' else ""
@@ -47,17 +79,14 @@ def create_technique_resource(material, resources):
                        st.sub.append(Statement("receive_shadows", True))
                if material.image_based_lighting:
                        st.sub.append(Statement("image_based_lighting", True))
+               if material.face_cull=='BACK':
+                       st.sub.append(Statement("face_cull", Token("CULL_BACK")))
 
                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
 
@@ -77,7 +106,7 @@ class MaterialExporter:
                for p in textured_props:
                        ctx.next_slice(p.texture.image)
 
-                       tex_name = p.texture.image.name+".tex2d"
+                       tex_name = texture_export.get_texture_name(p.texture, p.tex_channels)
                        if tex_name not in resources:
                                resources[tex_name] = texture_export.export_texture(p.texture, p.tex_channels)
 
@@ -93,6 +122,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:
@@ -117,14 +152,17 @@ 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
 
        def create_property_statement(self, mat_res, prop, resources):
                from .datafile import Statement
                if prop.texture:
-                       tex_res = resources[prop.texture.image.name+".tex2d"]
-                       from .util import basename
+                       from .export_texture import TextureExporter
+                       texture_export = TextureExporter()
+                       tex_res = resources[texture_export.get_texture_name(prop.texture, prop.tex_channels)]
                        return mat_res.create_reference_statement(prop.tex_keyword, tex_res)
                elif not prop.keyword:
                        return
@@ -133,6 +171,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):
@@ -140,11 +189,12 @@ class MaterialAtlasExporter:
 
        def export_technique_resources(self, material_atlas, resources):
                from .datafile import Resource, Statement, Token
-               base_color_name = material_atlas.name+"_base_color.tex2d"
+               base_color_name = material_atlas.name+"_base_color.tex"
                base_color_res = resources.get(base_color_name)
                if not base_color_res:
-                       base_color_res = Resource(base_color_name, "texture2d")
+                       base_color_res = Resource(base_color_name, "texture")
 
+                       base_color_res.statements.append(Statement("type", Token("\\2d")))
                        base_color_res.statements.append(Statement("storage", Token('SRGB_ALPHA'), *material_atlas.size))
                        base_color_res.statements.append(Statement("raw_data", material_atlas.base_color_data))