Make it possible to export instance arrays from 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 f01745b98fdf00a1ef7cbc610d14fe03d1c12d38..64d11b8689bc90806349aaab6df375869e187a7f 100644 (file)
--- a/blender/io_mspgl/export_material.py
+++ b/blender/io_mspgl/export_material.py
@@ -30,11 +30,13 @@ 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)
+               for thsm in (False, True):
+                       occluder_variant, occluder_spec_values = self.get_occluder_shader_variant(material, thsm)
+                       if occluder_spec_values:
+                               base_variant = "_thsm" if thsm else ""
+                               shader_name = "occluder{}.shader".format(occluder_variant)
                                if shader_name not in resources:
-                                       resources[shader_name] = self.export_shader(shader_name, "occluder{}.glsl".format(detail), {"use_alpha_cutoff":True}, resources)
+                                       resources[shader_name] = self.export_shader(shader_name, "occluder{}.glsl".format(base_variant), occluder_spec_values, resources)
 
        def export_technique(self, material, resources):
                from .material import Material
@@ -90,25 +92,34 @@ class MaterialExporter:
                                st.sub.append(Statement("receive_shadows", True))
                        if material.image_based_lighting:
                                st.sub.append(Statement("image_based_lighting", True))
+                       if material.instancing:
+                               st.sub.append(Statement("instancing", True))
                        if material.face_cull=='BACK':
                                st.sub.append(Statement("face_cull", Token("CULL_BACK")))
 
                        tech_res.statements.append(st)
 
                        if material.cast_shadows:
-                               tech_res.statements.append(self.create_shadow_method(tech_res, material, resources, ""));
-                               tech_res.statements.append(self.create_shadow_method(tech_res, material, resources, "_thsm"));
+                               tech_res.statements.append(self.create_shadow_method(tech_res, material, resources, False));
+                               tech_res.statements.append(self.create_shadow_method(tech_res, material, resources, True));
 
                return tech_res
 
-       def create_shadow_method(self, tech_res, material, resources, detail):
+       def create_shadow_method(self, tech_res, material, resources, thsm):
                from .datafile import Statement, Token
 
-               color_prop = next((p for p in material.properties if p.keyword and "color" in p.keyword), None)
+               occluder_variant, occluder_spec_values = self.get_occluder_shader_variant(material, thsm)
+
+               shader_stem = "occluder{}.shader" if occluder_spec_values else "occluder{}.glsl.shader"
+               shader_name = shader_stem.format(occluder_variant)
 
-               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)]))
+               st = Statement("method", "shadow"+("_thsm" if thsm else ""))
+               if occluder_spec_values:
+                       st.sub.append(tech_res.create_reference_statement("shader", resources[shader_name]))
+               else:
+                       st.sub.append(Statement("shader", shader_name))
+
+               if occluder_spec_values.get("use_alpha_cutoff"):
                        ss = Statement("texture", "alpha_map")
 
                        from .export_texture import TextureExporter
@@ -116,6 +127,7 @@ class MaterialExporter:
                        texture_export = TextureExporter()
                        sampler_export = SamplerExporter()
 
+                       color_prop = material.properties[0]
                        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)]))
@@ -124,14 +136,29 @@ class MaterialExporter:
                        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 get_occluder_shader_variant(self, material, thsm):
+               variant = ""
+               if thsm:
+                       variant += "_thsm"
+
+               spec_values = {}
+
+               color_prop = material.properties[0]
+               if material.cast_shadows and material.alpha_cutoff>0.0:
+                       spec_values["use_alpha_cutoff"] = True
+                       variant += "_masked"
+               if material.instancing:
+                       spec_values["use_instancing"] = True
+                       variant += "_instanced"
+
+               return (variant, spec_values)
+
        def export_material(self, material, resources):
                from .datafile import Resource, Statement, Token
                mat_res = Resource(material.name+".mat", "material")