Incremented version to 1.1.1

README.md

@@ -3,3 +3,6 @@
 This is a Blender addon allowing you to export static meshes to the now-defunct ASE (ASCII Scene Export) format still in use in legacy programs like Unreal Tournament 2004.
 
 Check out [this video](https://www.youtube.com/watch?v=gpmBxCGHQjU) on how to install and use the addon.
+
+Resources:
+* https://wiki.beyondunreal.com/Legacy:ASE_File_Format

src/__init__.py

@@ -2,7 +2,7 @@ bl_info = {
     'name': 'ASCII Scene Export',
     'description': 'Export ASE (ASCII Scene Export) files',
     'author': 'Colin Basnett (Darklight Games)',
-    'version': (1, 0, 1),
+    'version': (1, 1, 2),
     'blender': (2, 90, 0),
     'location': 'File > Import-Export',
     'warning': 'This add-on is under development.',
@@ -21,8 +21,6 @@ if 'bpy' in locals():
 
 import bpy
 import bpy.utils.previews
-from bpy.props import IntProperty, CollectionProperty, StringProperty
-import os
 from . import ase
 from . import builder
 from . import writer

src/ase.py

@@ -26,14 +26,20 @@ def is_collision_name(name):
     return name.startswith('MCDCX_')
 
 
+class ASEUVLayer(object):
+    def __init__(self):
+        self.texture_vertices = []
+
+
 class ASEGeometryObject(object):
     def __init__(self):
         self.name = ''
         self.vertices = []
-        self.texture_vertices = []
+        self.uv_layers = []
         self.faces = []
         self.texture_vertex_faces = []
         self.face_normals = []
+        self.vertex_colors = []
         self.vertex_offset = 0
         self.texture_vertex_offset = 0
 

src/builder.py

@@ -34,10 +34,18 @@ class ASEBuilder(object):
                     main_geometry_object = geometry_object
                 ase.geometry_objects.append(geometry_object)
 
+            if geometry_object.is_collision:
+                bm = bmesh.new()
+                bm.from_mesh(obj.data)
+                for edge in bm.edges:
+                    if not edge.is_manifold:
+                        raise ASEBuilderError(f'Collision mesh \'{obj.name}\' is not manifold')
+                    if not edge.is_convex:
+                        raise ASEBuilderError(f'Collision mesh \'{obj.name}\' is not convex')
+
             if not geometry_object.is_collision and len(mesh_data.materials) == 0:
                 raise ASEBuilderError(f'Mesh \'{obj.name}\' must have at least one material')
 
-            geometry_object.vertex_offset += len(geometry_object.vertices)
             vertex_transform = Matrix.Scale(options.scale, 4) @ Matrix.Rotation(math.pi, 4, 'Z') @ obj.matrix_world
             for vertex_index, vertex in enumerate(mesh_data.vertices):
                 geometry_object.vertices.append(vertex_transform @ vertex.co)
@@ -69,6 +77,11 @@ class ASEBuilder(object):
                     face.material_index = material_indices[loop_triangle.material_index]
                 # The UT2K4 importer only accepts 32 smoothing groups. Anything past this completely mangles the
                 # smoothing groups and effectively makes the whole model use sharp-edge rendering.
+                # The fix is to constrain the smoothing group between 0 and 31 by applying a modulo of 32 to the actual
+                # smoothing group index.
+                # This may result in bad calculated normals on export in rare cases. For example, if a face with a
+                # smoothing group of 3 is adjacent to a face with a smoothing group of 35 (35 % 32 == 3), those faces
+                # will be treated as part of the same smoothing group.
                 face.smoothing = (poly_groups[loop_triangle.polygon_index] - 1) % 32
                 geometry_object.faces.append(face)
 
@@ -85,14 +98,15 @@ class ASEBuilder(object):
                         face_normal.vertex_normals.append(vertex_normal)
                     geometry_object.face_normals.append(face_normal)
 
-            uv_layer = mesh_data.uv_layers.active.data
-
-            # Texture Coordinates
-            geometry_object.texture_vertex_offset += len(geometry_object.texture_vertices)
             if not geometry_object.is_collision:
-                for loop_index, loop in enumerate(mesh_data.loops):
+                # Texture Coordinates
-                    u, v = uv_layer[loop_index].uv
+                for i, uv_layer_data in enumerate([x.data for x in mesh_data.uv_layers]):
-                    geometry_object.texture_vertices.append((u, v, 0.0))
+                    if i >= len(geometry_object.uv_layers):
+                        geometry_object.uv_layers.append(ASEUVLayer())
+                    uv_layer = geometry_object.uv_layers[i]
+                    for loop_index, loop in enumerate(mesh_data.loops):
+                        u, v = uv_layer_data[loop_index].uv
+                        uv_layer.texture_vertices.append((u, v, 0.0))
 
             # Texture Faces
             if not geometry_object.is_collision:
@@ -103,6 +117,16 @@ class ASEBuilder(object):
                         geometry_object.texture_vertex_offset + loop_triangle.loops[2]
                     ))
 
+            # Vertex Colors
+            if len(mesh_data.vertex_colors) > 0:
+                vertex_colors = mesh_data.vertex_colors.active.data
+                for color in map(lambda x: x.color, vertex_colors):
+                    geometry_object.vertex_colors.append(tuple(color[0:3]))
+
+            # Update data offsets for next iteration
+            geometry_object.texture_vertex_offset = len(mesh_data.loops)
+            geometry_object.vertex_offset = len(geometry_object.vertices)
+
         if len(ase.geometry_objects) == 0:
             raise ASEBuilderError('At least one mesh object must be selected')
 

src/exporter.py

@@ -1,6 +1,6 @@
 import bpy
 import bpy_extras
-from bpy.props import StringProperty, FloatProperty, EnumProperty
+from bpy.props import StringProperty, FloatProperty, EnumProperty, BoolProperty
 from .builder import *
 from .writer import *
 
@@ -19,7 +19,7 @@ class ASE_OT_ExportOperator(bpy.types.Operator, bpy_extras.io_utils.ExportHelper
         maxlen=255,  # Max internal buffer length, longer would be hilighted.
     )
 
-    units = EnumProperty(
+    units: EnumProperty(
         items=(('M', 'Meters', ''),
                ('U', 'Unreal', '')),
         name='Units'

src/writer.py

@@ -146,21 +146,23 @@ class ASEWriter(object):
                 face_node.push_sub_command('MESH_MTLID').push_datum(face.material_index)
 
             # Texture Coordinates
-            if len(geometry_object.texture_vertices) > 0:
+            for i, uv_layer in enumerate(geometry_object.uv_layers):
-                mesh_node.push_child('MESH_NUMTVERTEX').push_datum(len(geometry_object.texture_vertices))
+                parent_node = mesh_node if i == 0 else mesh_node.push_child('MESH_MAPPINGCHANNEL')
-                tvertlist_node = mesh_node.push_child('MESH_TVERTLIST')
+                if i > 0:
-                for tvert_index, tvert in enumerate(geometry_object.texture_vertices):
+                    parent_node.push_datum(i + 1)
+                parent_node.push_child('MESH_NUMTVERTEX').push_datum(len(uv_layer.texture_vertices))
+                tvertlist_node = parent_node.push_child('MESH_TVERTLIST')
+                for tvert_index, tvert in enumerate(uv_layer.texture_vertices):
                     tvert_node = tvertlist_node.push_child('MESH_TVERT')
                     tvert_node.push_datum(tvert_index)
                     tvert_node.push_data(list(tvert))
-
+                # Texture Faces
-            # Texture Faces
+                if len(geometry_object.texture_vertex_faces) > 0:
-            if len(geometry_object.texture_vertex_faces) > 0:
+                    parent_node.push_child('MESH_NUMTVFACES').push_datum(len(geometry_object.texture_vertex_faces))
-                mesh_node.push_child('MESH_NUMTVFACES').push_datum(len(geometry_object.texture_vertex_faces))
+                    texture_faces_node = parent_node.push_child('MESH_TFACELIST')
-                texture_faces_node = mesh_node.push_child('MESH_TFACELIST')
+                    for texture_face_index, texture_face in enumerate(geometry_object.texture_vertex_faces):
-                for texture_face_index, texture_face in enumerate(geometry_object.texture_vertex_faces):
+                        texture_face_node = texture_faces_node.push_child('MESH_TFACE')
-                    texture_face_node = texture_faces_node.push_child('MESH_TFACE')
+                        texture_face_node.push_data([texture_face_index] + list(texture_face))
-                    texture_face_node.push_data([texture_face_index] + list(texture_face))
 
             # Normals
             if len(geometry_object.face_normals) > 0:
@@ -174,6 +176,18 @@ class ASEWriter(object):
                         vertex_normal_node.push_datum(vertex_normal.vertex_index)
                         vertex_normal_node.push_data(list(vertex_normal.normal))
 
+            # Vertex Colors
+            if len(geometry_object.vertex_colors) > 0:
+                mesh_node.push_child('MESH_NUMCVERTEX').push_datum(len(geometry_object.vertex_colors))
+                cvert_list = mesh_node.push_child('MESH_CVERTLIST')
+                for i, vertex_color in enumerate(geometry_object.vertex_colors):
+                    cvert_list.push_child('MESH_VERTCOL').push_datum(i).push_data(vertex_color)
+                parent_node.push_child('MESH_NUMCVFACES').push_datum(len(geometry_object.texture_vertex_faces))
+                texture_faces_node = parent_node.push_child('MESH_CFACELIST')
+                for texture_face_index, texture_face in enumerate(geometry_object.texture_vertex_faces):
+                    texture_face_node = texture_faces_node.push_child('MESH_CFACE')
+                    texture_face_node.push_data([texture_face_index] + list(texture_face))
+
             geomobject_node.push_child('MATERIAL_REF').push_datum(0)
 
         return root