Merge remote-tracking branch 'hoikas/stencils'

korman/exporter/manager.py

@@ -200,13 +200,13 @@ class ExportManager:
             location = self._pages[bl.plasma_object.page]
         return self._nodes[location].key
 
-    def get_textures_page(self, layer):
+    def get_textures_page(self, key):
         """Gets the appropriate page for a texture for a given plLayer"""
         # The point of this is to account for per-page textures...
         if "Textures" in self._pages:
             return self._pages["Textures"]
         else:
-            return layer.key.location
+            return key.location
 
     def has_coordiface(self, bo):
         if bo.type in {"CAMERA", "EMPTY", "LAMP"}:

korman/exporter/material.py

@@ -87,10 +87,9 @@ class _GLTexture:
         # NOTE: the variable names are correct for GL_RGBA. We'll still get the right values for
         # BGRA, obviously, but red will suddenly be... blue. Yeah.
         if calc_alpha:
-            for i in range(size, 4):
+            for i in range(0, size, 4):
-                base = i*4
+                r, g, b = buf[i:i+3]
-                r, g, b = buf[base:base+2]
+                buf[i+3] = int((r + g + b) / 3)
-                buf[base+3] = int((r + g + b) / 3)
         return bytes(buf)
 
     def _get_integer(self, arg):
@@ -108,7 +107,7 @@ class _GLTexture:
 
 
 class _Texture:
-    def __init__(self, texture=None, image=None, use_alpha=None):
+    def __init__(self, texture=None, image=None, use_alpha=None, force_calc_alpha=False):
         assert (texture or image)
 
         if texture is not None:
@@ -120,7 +119,10 @@ class _Texture:
             self.calc_alpha = False
             self.mipmap = False
 
-        if use_alpha is None:
+        if force_calc_alpha or self.calc_alpha:
+            self.calc_alpha = True
+            self.use_alpha  = True
+        elif use_alpha is None:
             self.use_alpha = (image.channels == 4 and image.use_alpha)
         else:
             self.use_alpha = use_alpha
@@ -169,13 +171,25 @@ class MaterialConverter:
         self._exporter = weakref.ref(exporter)
         self._pending = {}
         self._alphatest = {}
+        self._tex_exporters = {
+            "ENVRIONMENT_MAP": self._export_texture_type_environment_map,
+            "IMAGE": self._export_texture_type_image,
+            "NONE": self._export_texture_type_none,
+        }
 
     def export_material(self, bo, bm):
         """Exports a Blender Material as an hsGMaterial"""
         print("    Exporting Material '{}'".format(bm.name))
 
         hsgmat = self._mgr.add_object(hsGMaterial, name=bm.name, bl=bo)
-        self._export_texture_slots(bo, bm, hsgmat)
+        slots = [slot for slot in bm.texture_slots if slot is not None and slot.use and
+                 slot.texture is not None and slot.texture.type in self._tex_exporters]
+
+        # Okay, I know this isn't Pythonic... But we're doing it this way because we might actually
+        # export many slots in one go. Think stencils.
+        i = 0
+        while i < len(slots):
+            i += self._export_texture_slot(bo, bm, hsgmat, slots, i)
 
         # Plasma makes several assumptions that every hsGMaterial has at least one layer. If this
         # material had no Textures, we will need to initialize a default layer
@@ -193,43 +207,64 @@ class MaterialConverter:
         # Looks like we're done...
         return hsgmat.key
 
-    def _export_texture_slots(self, bo, bm, hsgmat):
+    def _export_texture_slot(self, bo, bm, hsgmat, slots, idx):
-        for slot in bm.texture_slots:
+        slot = slots[idx]
-            if slot is None or not slot.use:
+        num_exported = 1
-                continue
+
-
+        name = "{}_{}".format(bm.name, slot.name)
-            name = "{}_{}".format(bm.name, slot.name)
+        print("        Exporting Plasma Layer '{}'".format(name))
-            print("        Exporting Plasma Layer '{}'".format(name))
+        layer = self._mgr.add_object(plLayer, name=name, bl=bo)
-            layer = self._mgr.add_object(plLayer, name=name, bl=bo)
+        self._propagate_material_settings(bm, layer)
-            self._propagate_material_settings(bm, layer)
+
-
+        # UVW Channel
-            # UVW Channel
+        for i, uvchan in enumerate(bo.data.tessface_uv_textures):
-            for i, uvchan in enumerate(bo.data.tessface_uv_textures):
+            if uvchan.name == slot.uv_layer:
-                if uvchan.name == slot.uv_layer:
+                layer.UVWSrc = i
-                    layer.UVWSrc = i
+                print("            Using UV Map #{} '{}'".format(i, name))
-                    print("            Using UV Map #{} '{}'".format(i, name))
+                break
-                    break
+        else:
-            else:
+            print("            No UVMap specified... Blindly using the first one, maybe it exists :|")
-                print("            No UVMap specified... Blindly using the first one, maybe it exists :|")
 
-            # General texture flags and such
+        state = layer.state
-            state = layer.state
+        if slot.use_stencil:
+            hsgmat.compFlags |= hsGMaterial.kCompNeedsBlendChannel
+            state.blendFlags |= hsGMatState.kBlendAlpha | hsGMatState.kBlendAlphaMult | hsGMatState.kBlendNoTexColor
+            state.clampFlags |= hsGMatState.kClampTexture
+            state.ZFlags |= hsGMatState.kZNoZWrite
+            layer.ambient = hsColorRGBA(1.0, 1.0, 1.0, 1.0)
+
+            # Plasma actually wants the next layer first, so let's export him
+            nextIdx = idx + 1
+            if len(slots) == nextIdx:
+                raise ExportError("Texture Slot '{}' wants to be a stencil, but there are no more TextureSlots.".format(slot.name))
+            print("            --- BEGIN STENCIL ---")
+            self._export_texture_slot(bo, bm, hsgmat, slots, nextIdx)
+            print("            ---  END STENCIL  ---")
+            num_exported += 1
+
+            # Now that we've exported the bugger, flag him as binding with this texture
+            prev_layer = hsgmat.layers[-1].object
+            prev_state = prev_layer.state
+            prev_state.miscFlags |= hsGMatState.kMiscBindNext | hsGMatState.kMiscRestartPassHere
+            if not prev_state.blendFlags & hsGMatState.kBlendMask:
+                prev_state.blendFlags |= hsGMatState.kBlendAlpha
+        else:
+            # Standard layer flags ahoy
             if slot.blend_type == "ADD":
                 state.blendFlags |= hsGMatState.kBlendAdd
             elif slot.blend_type == "MULTIPLY":
                 state.blendFlags |= hsGMatState.kBlendMult
 
-            # Export the specific texture type
+        # Export the specific texture type
-            texture = slot.texture
+        texture = slot.texture
-            export_fn = "_export_texture_type_{}".format(texture.type.lower())
+        self._tex_exporters[texture.type](bo, hsgmat, layer, slot)
-            if not hasattr(self, export_fn):
+        hsgmat.addLayer(layer.key)
-                raise explosions.UnsupportedTextureError(texture, bm)
+        return num_exported
-            getattr(self, export_fn)(bo, hsgmat, layer, texture)
-            hsgmat.addLayer(layer.key)
 
-    def _export_texture_type_environment_map(self, bo, hsgmat, layer, texture):
+    def _export_texture_type_environment_map(self, bo, hsgmat, layer, slot):
         """Exports a Blender EnvironmentMapTexture to a plLayer"""
 
+        texture = slot.texture
         bl_env = texture.environment_map
         if bl_env.source in {"STATIC", "ANIMATED"}:
             if bl_env.mapping == "PLANE" and self._mgr.getVer() >= pvMoul:
@@ -324,21 +359,25 @@ class MaterialConverter:
 
         return pl_env.key
 
-    def _export_texture_type_image(self, bo, hsgmat, layer, texture):
+    def _export_texture_type_image(self, bo, hsgmat, layer, slot):
         """Exports a Blender ImageTexture to a plLayer"""
+        texture = slot.texture
 
         # Does the image have any alpha at all?
-        has_alpha = texture.use_calculate_alpha or self._test_image_alpha(texture.image)
+        has_alpha = texture.use_calculate_alpha or slot.use_stencil or self._test_image_alpha(texture.image)
         if (texture.image.use_alpha and texture.use_alpha) and not has_alpha:
             warning = "'{}' wants to use alpha, but '{}' is opaque".format(texture.name, texture.image.name)
             self._exporter().report.warn(warning, indent=3)
 
         # First, let's apply any relevant flags
         state = layer.state
-        if texture.invert_alpha and has_alpha:
+        if not slot.use_stencil:
-            state.blendFlags |= hsGMatState.kBlendInvertAlpha
+            # mutually exclusive blend flags
-        if texture.use_alpha and has_alpha:
+            if texture.use_alpha and has_alpha:
-            state.blendFlags |= hsGMatState.kBlendAlpha
+                state.blendFlags |= hsGMatState.kBlendAlpha
+
+            if texture.invert_alpha and has_alpha:
+                state.blendFlags |= hsGMatState.kBlendInvertAlpha
         if texture.extension == "CLIP":
             state.clampFlags |= hsGMatState.kClampTexture
 
@@ -349,13 +388,13 @@ class MaterialConverter:
         if texture.image is None:
             bitmap = self.add_object(plDynamicTextMap, name="{}_DynText".format(layer.key.name), bl=bo)
         else:
-            key = _Texture(texture=texture, use_alpha=has_alpha)
+            key = _Texture(texture=texture, use_alpha=has_alpha, force_calc_alpha=slot.use_stencil)
             if key not in self._pending:
                 print("            Stashing '{}' for conversion as '{}'".format(texture.image.name, str(key)))
-                self._pending[key] = [layer,]
+                self._pending[key] = [layer.key,]
             else:
                 print("            Found another user of '{}'".format(texture.image.name))
-                self._pending[key].append(layer)
+                self._pending[key].append(layer.key)
 
     def _export_texture_type_none(self, bo, hsgmat, layer, texture):
         # We'll allow this, just for sanity's sake...
@@ -431,7 +470,7 @@ class MaterialConverter:
 
             print("    Adding to Layer(s)")
             for layer in layers:
-                print("        {}".format(layer.key.name))
+                print("        {}".format(layer.name))
                 page = mgr.get_textures_page(layer) # Layer's page or Textures.prp
 
                 # If we haven't created this plMipmap in the page (either layer's page or Textures.prp),
@@ -447,7 +486,7 @@ class MaterialConverter:
                     pages[page] = mipmap
                 else:
                     mipmap = pages[page]
-                layer.texture = mipmap.key
+                layer.object.texture = mipmap.key
 
     def get_materials(self, bo):
         return self._obj2mat[bo]

korman/exporter/mesh.py

@@ -42,7 +42,7 @@ class _RenderLevel:
 
         # Naive... BlendSpans (any blending on the first layer) are MAJOR_BLEND
         if blendSpan:
-            self.major = self.MAJOR_BLEND
+            self.major = self.MAJOR_DEFAULT
 
         # We use the blender material's pass index (which we stashed in the hsGMaterial) to increment
         # the render pass, just like it says...
@@ -69,8 +69,12 @@ class _RenderLevel:
 
 class _DrawableCriteria:
     def __init__(self, hsgmat, pass_index):
-        _layer = hsgmat.layers[0].object # better doggone well have a layer...
+        for layer in hsgmat.layers:
-        self.blend_span = bool(_layer.state.blendFlags & hsGMatState.kBlendMask)
+            if layer.object.state.blendFlags & hsGMatState.kBlendMask:
+                self.blend_span = True
+                break
+        else:
+            self.blend_span = False
         self.criteria = 0 # TODO
         self.render_level = _RenderLevel(hsgmat, pass_index, self.blend_span)