Merge pull request #68 from MrClock8163/dev

MrClock8163 · web-flow · commit 039869722aa2 · 2024-09-09T22:47:30.000+02:00
v2.4.0
diff --git a/.gitattributes b/.gitattributes
@@ -1,3 +1,7 @@
 * text=auto
 
 * text eol=lf
+
+*.png binary
+*.p3d binary
+*.blend binary
diff --git a/.gitignore b/.gitignore
@@ -1,6 +1,7 @@
 *.blend*
 *.bat
 *.zip
+test/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
diff --git a/Arma3ObjectBuilder/CHANGELOG.md b/Arma3ObjectBuilder/CHANGELOG.md
@@ -1,5 +1,21 @@
 # Changelog
 
+## [v2.4.0](https://github.com/MrClock8163/Arma3ObjectBuilder/releases/tag/v2.4.0) (Blender 2.90 -> 4.2)
+
+### Added
+
+- import-export:
+  - Terrain Builder object list import
+  - Terrain Builder object list export
+
+### Changed
+
+- LZO1X decompression for BMTR files was improved
+
+### Fixed
+
+- the mandatory part of the LOD validation during export was mistakenly using the Warnings Are Errors setting even if verbose LOD validation was not enabled
+
 ## [v2.3.5](https://github.com/MrClock8163/Arma3ObjectBuilder/releases/tag/v2.3.5) (Blender 2.90 -> 4.2)
 
 ### Added
diff --git a/Arma3ObjectBuilder/README.md b/Arma3ObjectBuilder/README.md
@@ -20,6 +20,8 @@ The documentation can be found on [GitBook](https://mrcmodding.gitbook.io/arma-3
 The add-on can be installed after either downloading a packaged release, or cloning the repository and manually packing it.
 For information about add-on installation, visit the official [Blender documentation](https://docs.blender.org/manual/en/latest/editors/preferences/addons.html) page about add-ons.
 
+For Blender 4.2 and higher, the add-on can also be installed from the official [Extensions repository](https://extensions.blender.org/add-ons/arma3objectbuilder).
+
 ## License
 
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
diff --git a/Arma3ObjectBuilder/__init__.py b/Arma3ObjectBuilder/__init__.py
@@ -2,7 +2,7 @@
     "name": "Arma 3 Object Builder",
     "description": "Collection of tools for editing Arma 3 content",
     "author": "MrClock (present add-on), Hans-Joerg \"Alwarren\" Frieden (original ArmaToolbox add-on)",
-    "version": (2, 3, 5),
+    "version": (2, 4, 0),
     "blender": (2, 90, 0),
     "location": "Object Builder panels",
     "warning": "",
@@ -330,6 +330,7 @@ def draw(self, context):
     ui.import_export_rtm,
     ui.import_export_mcfg,
     ui.import_export_armature,
+    ui.import_export_tbcsv,
     ui.import_export_asc,
     ui.tool_outliner,
     ui.tool_mass,
diff --git a/Arma3ObjectBuilder/blender_manifest.toml b/Arma3ObjectBuilder/blender_manifest.toml
@@ -5,7 +5,7 @@ type = "add-on"
 id = "Arma3ObjectBuilder"
 name = "Arma 3 Object Builder"
 tagline = "Comprehensive add-on for modding Arma 3"
-version = "2.3.5"
+version = "2.4.0"
 blender_version_min = "4.2.0"
 website = "https://mrcmodding.gitbook.io/arma-3-object-builder/home"
 tags = ["Import-Export", "Game Engine", "Object"]
diff --git a/Arma3ObjectBuilder/io/__init__.py b/Arma3ObjectBuilder/io/__init__.py
@@ -3,6 +3,7 @@
 from . import data_p3d
 from . import data_rap
 from . import data_rtm
+from . import data_tbcsv
 from . import export_asc
 from . import export_mcfg
 from . import export_p3d
diff --git a/Arma3ObjectBuilder/io/compression.py b/Arma3ObjectBuilder/io/compression.py
@@ -22,37 +22,28 @@ def lzo1x_decompress(file, expected):
     output = bytearray()
 
     def check_free_space(length):
-        output_length = len(output)
-        free_space = expected - output_length
+        free_space = expected - len(output)
         if free_space < length:
-            raise LZO_Error("Output overrun (free buffer: %d, match length: %d)" % (expected - output_length, length))
+            raise LZO_Error("Output overrun (free buffer: %d, match length: %d)" % (free_space, length))
 
     def read1():
-        nonlocal file
         return struct.unpack('B', file.read(1))[0]
 
     def read(size):
-        nonlocal file
         return struct.unpack('%dB' % size, file.read(size))
     
     def read_le16():
-        nonlocal file
         return struct.unpack('<H', file.read(2))[0]
     
     def extend(items):
         nonlocal output
         output.extend(items)
-    
-    def append(item):
-        nonlocal output
-        output.append(item)
 
     def copy_literal(length):
         check_free_space(length)
         extend(read(length))
     
     def copy_match(distance, length):
-        nonlocal output
         output_length = len(output)
 
         if output_length < distance:
@@ -63,15 +54,12 @@ def copy_match(distance, length):
         # It is valid to have length that is longer than the back pointer distance, which creates a repeating pattern,
         # copying the same bytes that were copied in this same command.
         # For this reason, we cannot simply take a slice of the output at the given point with the given length, as
-        # some of the bytes might not yet be there. We have to copy 1 by 1, like the C implementations.
-        ptr = output_length - distance
-        for i in range(length):
-            append(output[ptr])
-            ptr += 1
+        # some of the bytes might not yet be there. We have to copy in chunks with size of the backpointer distance.
+        start = output_length - distance
+        extend(output[start:] * (length // distance)) # copy as many whole chunks as possible
+        extend(output[start:(start + (length % distance))]) # copy remainder
     
     def get_length(x, mask):
-        nonlocal file
-
         length = x & mask
         if not length:
             while True:
@@ -91,8 +79,25 @@ def get_length(x, mask):
         state = min(4, length)
         x = read1()
     
-    while True:        
-        if x > 127:
+    while True:
+        if x <= 15:
+            if not state:
+                length = 3 + get_length(x, 15)
+                copy_literal(length)
+                state = 4
+            elif state < 4:
+                length = 2
+                state = x & 3
+                distance = (read1() << 2) + (x >> 2) + 1
+                copy_match(distance, length)
+                copy_literal(state)
+            elif state == 4:
+                length = 3
+                state = x & 3
+                distance = (read1() << 2) + (x >> 2) + 2049
+                copy_match(distance, length)
+                copy_literal(state)
+        elif x > 127:
             state = x & 3
             length = 5 + ((x >> 5) & 3)
             distance = (read1() << 3) + ((x >> 2) & 7) + 1
@@ -111,7 +116,7 @@ def get_length(x, mask):
             state = extra & 3
             copy_match(distance, length)
             copy_literal(state)
-        elif x > 15:
+        else:
             length = 2 + get_length(x, 7)
             extra = read_le16()
             distance = 16384 + ((x & 8) << 11) + (extra >> 2)
@@ -124,24 +129,7 @@ def get_length(x, mask):
             
             copy_match(distance, length)
             copy_literal(state)
-        else:
-            if not state:
-                length = 3 + get_length(x, 15)
-                copy_literal(length)
-                state = 4
-            elif state < 4:
-                length = 2
-                state = x & 3
-                distance = (read1() << 2) + (x >> 2) + 1
-                copy_match(distance, length)
-                copy_literal(state)
-            elif state == 4:
-                length = 3
-                state = x & 3
-                distance = (read1() << 2) + (x >> 2) + 2049
-                copy_match(distance, length)
-                copy_literal(state)
-        
+
         x = read1()
 
     if expected - len(output):
diff --git a/Arma3ObjectBuilder/io/data_tbcsv.py b/Arma3ObjectBuilder/io/data_tbcsv.py
@@ -0,0 +1,81 @@
+# Class structure and read-write methods for handling the object list format
+# used for interoperability with Terrain Builder
+
+
+class TBCSV_Error(Exception):
+    def __str__(self):
+        return "TBCSV - %s" % super().__str__()
+
+
+class TBCSV_Transform:
+    def __init__(self, loc = (0, 0, 0), rot = (0, 0, 0), scale = 1):
+        self.loc = loc
+        self.rot = rot
+        self.scale = scale
+    
+    def print(self):
+        east, north, elev = self.loc
+        yaw, pitch, roll = self.rot
+
+        return ";".join(["%.8f" % value for value in (east, north, yaw, pitch, roll, self.scale, elev)])
+
+
+class TBCSV_Object:
+    def __init__(self, name = ""):
+        self.name = name
+        self.transform = TBCSV_Transform()
+    
+    @classmethod
+    def parse(cls, data):
+        fields = data.rstrip(";").split(";")
+        if len(fields) != 8:
+            raise TBCSV_Error("Invalid row, unexpected field count: \"%s\"" % data)
+        
+        name, east, north, yaw, pitch, roll, scale, elev = fields
+
+        output = cls()
+        try:
+            output.name = name[1:-1]
+            output.transform = TBCSV_Transform((float(east), float(north), float(elev)), (float(yaw), float(pitch), float(roll)), float(scale))
+        except Exception as e:
+            raise TBCSV_Error(e)
+
+        return output
+    
+    def print(self):
+        return "\"%s\";%s\n" % (self.name, self.transform.print())
+
+
+class TBCSV_File:
+    def __init__(self):
+        self.source = ""
+        self.objects = []
+    
+    @classmethod
+    def read(cls, file):
+        output = cls()
+
+        for line in file:
+            if line == "\n":
+                continue
+            output.objects.append(TBCSV_Object.parse(line.strip()))
+
+        return output
+    
+    @classmethod
+    def read_file(cls, filepath):
+        output = None
+        with open(filepath, "tr") as  file:
+            output = cls.read(file)
+        
+        output.source = filepath
+        
+        return output
+    
+    def write(self, file):
+        for obj in self.objects:
+            file.write(obj.print())
+    
+    def write_file(self, filepath):
+        with open(filepath, "wt") as file:
+            self.write(file)
diff --git a/Arma3ObjectBuilder/io/export_p3d.py b/Arma3ObjectBuilder/io/export_p3d.py
@@ -353,10 +353,10 @@ def get_lod_data(operator, context, validator, temp_collection):
         is_valid_copies = []
         for copy in main_obj.a3ob_properties_object.copies:
             with temporary_component(operator, main_obj):
-                is_valid_copies.append(is_valid and validator.validate_lod(main_obj, copy.lod, True, operator.validate_lods_warning_errors, operator.relative_paths))
+                is_valid_copies.append(is_valid and validator.validate_lod(main_obj, copy.lod, True, operator.validate_lods_warning_errors and operator.validate_lods, operator.relative_paths))
 
         with temporary_component(operator, main_obj):
-            is_valid &= validator.validate_lod(main_obj, main_obj.a3ob_properties_object.lod, True, operator.validate_lods_warning_errors, operator.relative_paths)
+            is_valid &= validator.validate_lod(main_obj, main_obj.a3ob_properties_object.lod, True, operator.validate_lods_warning_errors and operator.validate_lods, operator.relative_paths)
 
         proxy_lookup = merge_proxy_objects(main_obj, proxy_objects, operator.relative_paths)
 
diff --git a/Arma3ObjectBuilder/io/export_tbcsv.py b/Arma3ObjectBuilder/io/export_tbcsv.py
@@ -0,0 +1,88 @@
+# Processing functions to export object positions into list format
+# acceptable by Terrain Builder
+# Thanks to HorribleGoat for the help and suggestions
+
+
+import time
+import math
+
+import bpy
+
+from . import data_tbcsv as tb
+from ..utilities.logger import ProcessLogger
+
+
+def include_object(obj, operator):
+    if obj.type != 'MESH':
+        return False
+    
+    if operator.only_lods and not obj.a3ob_properties_object.is_a3_lod:
+        return False
+
+    return True
+
+
+def get_object_name(obj, operator):
+    if operator.name_source == 'COLLECTION' and operator.collection:
+        return operator.collection
+    elif operator.name_source == 'PROPERTY' and obj.get(operator.name_prop):
+        return obj.get(operator.name_prop)
+    elif operator.name_source == 'OBJECT':
+        return obj.name.split(".")[0]
+    
+    return ""
+
+
+def matrix_to_transform(operator, mat):
+    trans = tb.TBCSV_Transform()
+
+    loc, rot, scale = mat.decompose()
+    pitch, roll, yaw = rot.to_euler('ZXY')
+    east, north, elev = loc
+    
+    trans.loc = (east + operator.coord_shift[0], north + operator.coord_shift[1], elev)
+    trans.rot = (math.degrees(-yaw), math.degrees(pitch), math.degrees(roll))
+    trans.scale = math.fsum([comp for comp in scale]) / 3
+
+    return trans
+
+
+def write_file(operator, context, file):
+    logger = ProcessLogger()
+    logger.step("Map objects list export to %s" % operator.filepath)
+    time_file_start = time.time()
+
+    targets = bpy.data.objects
+    if operator.targets == 'SCENE':
+        targets = context.scene.objects
+    elif operator.targets == 'SELECTION':
+        targets = context.selected_objects
+
+    if operator.only_lods:
+        logger.log("Exporting LOD objects only")
+    
+    if operator.collection:
+        if not bpy.data.collections.get(operator.collection):
+            raise tb.TBCSV_Error("Collection (%s) was not found" % operator.collection)
+        
+        logger.log("Exporting collection")
+        targets = bpy.data.collections.get(operator.collection).objects
+
+    tbcsv = tb.TBCSV_File()
+    for obj in (target for target in targets if include_object(target, operator)):
+        name = get_object_name(obj, operator)
+        if not name:
+            logger.log("Could not determine name for %s" % obj.name)
+            continue
+
+        entry = tb.TBCSV_Object(name)
+        entry.transform = matrix_to_transform(operator, obj.matrix_world)
+        tbcsv.objects.append(entry)
+    
+    logger.log("Exported objects: %d" % len(tbcsv.objects))
+    
+    tbcsv.write(file)
+
+    logger.step("Map objects list export finished in %f sec" % (time.time() - time_file_start))
+
+    return len(tbcsv.objects)
diff --git a/Arma3ObjectBuilder/io/import_tbcsv.py b/Arma3ObjectBuilder/io/import_tbcsv.py
diff --git a/Arma3ObjectBuilder/ui/__init__.py b/Arma3ObjectBuilder/ui/__init__.py
diff --git a/Arma3ObjectBuilder/ui/import_export_tbcsv.py b/Arma3ObjectBuilder/ui/import_export_tbcsv.py
diff --git a/requirements.txt b/requirements.txt
