Add support for use of newly discovered shader filenames

BlenderIO/Export.py

@@ -20,6 +20,9 @@ class ExportDSCS(bpy.types.Operator, ExportHelper):
 
     def export_file(self, context, filepath):
         model_data = IntermediateFormat()
+        export_folder = os.path.join(*os.path.split(filepath)[:-1])
+        export_shaders_folder = os.path.join(export_folder, 'shaders')
+        os.makedirs(export_shaders_folder, exist_ok=True)
 
         parent_obj = bpy.context.selected_objects[0]
         sel_obj = None
@@ -119,10 +122,15 @@ def export_file(self, context, filepath):
             node_tree = bmat.node_tree
             material.name = bmat.name
             material.unknown_data['unknown_0x00'] = bmat['unknown_0x00']
-            material.unknown_data['unknown_0x10'] = bmat['unknown_0x10']
-            material.unknown_data['unknown_0x11'] = bmat['unknown_0x11']
-            material.unknown_data['unknown_0x12'] = bmat['unknown_0x12']
+            material.unknown_data['unknown_0x02'] = bmat['unknown_0x02']
+            material.shader_hex = bmat['shader_hex']
             material.unknown_data['unknown_0x16'] = bmat['unknown_0x16']
+
+            for shader_filename in os.listdir(bmat['shaders_folder']):
+                if shader_filename[:35] == material.shader_hex:
+                    shutil.copy2(os.path.join(bmat['shaders_folder'], shader_filename),
+                                 os.path.join(export_shaders_folder, shader_filename))
+
             for key in bmat.keys():
                 cstring_1 = 'type_1_component_'
                 cstring_2 = 'type_2_component_'

BlenderIO/Import.py

@@ -116,9 +116,9 @@ def import_file(self, context, filepath):
             new_material = bpy.data.materials.new(name=IF_material.name)
             # Unknown data
             new_material['unknown_0x00'] = IF_material.unknown_data['unknown_0x00']
-            new_material['unknown_0x10'] = IF_material.unknown_data['unknown_0x10']
-            new_material['unknown_0x11'] = IF_material.unknown_data['unknown_0x11']
-            new_material['unknown_0x12'] = IF_material.unknown_data['unknown_0x12']
+            new_material['unknown_0x02'] = IF_material.unknown_data['unknown_0x02']
+            new_material['shader_hex'] = IF_material.shader_hex
+            new_material['shaders_folder'] = os.path.join(*os.path.split(filepath)[:-1], 'shaders')
             new_material['unknown_0x16'] = IF_material.unknown_data['unknown_0x16']
             new_material['temp_reference_textures'] = [tex.name for tex in model_data.textures]
             for key in IF_material.unknown_data:

CollatedData/FromReadWrites.py

@@ -126,9 +126,8 @@ def add_materials(model_data, imported_namedata, imported_geomdata, filename):
 
         # Add unknown data
         model_data.materials[-1].unknown_data['unknown_0x00'] = material.unknown_0x00
-        model_data.materials[-1].unknown_data['unknown_0x10'] = material.unknown_0x10
-        model_data.materials[-1].unknown_data['unknown_0x11'] = material.unknown_0x11
-        model_data.materials[-1].unknown_data['unknown_0x12'] = material.unknown_0x12
+        model_data.materials[-1].unknown_data['unknown_0x02'] = material.unknown_0x00
+        model_data.materials[-1].shader_hex = material.shader_hex
         model_data.materials[-1].unknown_data['unknown_0x16'] = material.unknown_0x16
 
         for i, material_component in enumerate(material.material_components):

CollatedData/IntermediateFormat.py

@@ -80,6 +80,7 @@ def __init__(self):
         self.texture_id = None
         self.rgba = None
         self.specular_coeff = None
+        self.shader_hex = None
 
         self.unknown_data = {}
 

CollatedData/ToReadWrites.py

@@ -135,9 +135,8 @@ def make_geomreader(filepath, model_data):
         geomReader.materials_start_ptr = virtual_pos if len(model_data.materials) > 0 else 0
         for material, materialReader in zip(model_data.materials, geomReader.material_data):
             materialReader.unknown_0x00 = material.unknown_data['unknown_0x00']
-            materialReader.unknown_0x10 = material.unknown_data['unknown_0x10']
-            materialReader.unknown_0x11 = material.unknown_data['unknown_0x11']
-            materialReader.unknown_0x12 = material.unknown_data['unknown_0x12']
+            materialReader.unknown_0x02 = material.unknown_data['unknown_0x02']
+            materialReader.shader_hex = material.shader_hex
             materialReader.unknown_0x16 = material.unknown_data['unknown_0x16']
 
             for key in material.unknown_data:

FileReaders/GeomReader/MaterialReader.py

@@ -30,15 +30,7 @@ def __init__(self, io_stream):
         # Header variables
         self.unknown_0x00 = None
         self.unknown_0x02 = None
-        self.unknown_0x04 = None
-        self.unknown_0x06 = None
-        self.unknown_0x08 = None
-        self.unknown_0x0A = None
-        self.unknown_0x0C = None
-        self.unknown_0x0E = None
-        self.unknown_0x10 = None
-        self.unknown_0x11 = None
-        self.unknown_0x12 = None
+        self.shader_hex = None
         self.num_material_components = None
         self.num_unknown_data = None
         self.unknown_0x16 = None
@@ -51,8 +43,10 @@ def __init__(self, io_stream):
 
     def read(self):
         self.read_write(self.read_buffer, 'read', self.read_raw, self.prepare_material_read)
+        self.interpret_material()
 
     def write(self):
+        self.reinterpret_material()
         self.read_write(self.write_buffer, 'write', self.write_raw, lambda: None)
 
     def read_write(self, rw_operator, rw_method_name, rw_operator_raw, preparation_operator):
@@ -62,20 +56,9 @@ def read_write(self, rw_operator, rw_method_name, rw_operator_raw, preparation_o
         self.rw_unknown_data(rw_method_name)
 
     def rw_header(self, rw_operator, rw_operator_raw):
-        # Changing 0x04 - 0x0E to random values results in no material drawn
-        # unknown_0x12 must be exactly correct - might be a data type or material type
-        # changing 0x16 to the other values seems to have no effect
-        rw_operator_raw('unknown_0x00', 16) #self.unpack('e')
-        #self.unknown_0x02 = self.unpack('e')
-        #self.unknown_0x04 = self.unpack('H')
-        #self.unknown_0x06 = self.unpack('H')
-        #self.unknown_0x08 = self.unpack('H')
-        #self.unknown_0x0A = self.unpack('H')
-        #self.unknown_0x0C = self.unpack('H'
-        #self.unknown_0x0E = self.unpack('H')  # These are all multiples of 4. Highly suggestive.
-        rw_operator('unknown_0x10', 'B')  # 0, except for one file, where it is 1
-        rw_operator('unknown_0x11', 'B')  # 0 or 128.
-        rw_operator('unknown_0x12', 'H')  # 0, 3, 4, 5, 6... possibly data type? No obvious pattern though...
+        rw_operator('unknown_0x00', 'H')
+        rw_operator('unknown_0x02', 'H')
+        rw_operator_raw('shader_hex', 16)
         rw_operator('num_material_components', 'B')  # Known
         rw_operator('num_unknown_data', 'B')  # Known
         rw_operator('unknown_0x16', 'H')  # 1, 3, or 5
@@ -94,6 +77,33 @@ def prepare_material_read(self):
         self.material_components = [MaterialComponent(self.bytestream) for _ in range(self.num_material_components)]
         self.unknown_data = [UnknownMaterialData(self.bytestream) for _ in range(self.num_unknown_data)]
 
+    def interpret_material(self):
+        self.shader_hex: bytes
+        shader_hex_pt_1 = self.shader_hex[0:4][::-1].hex()
+        shader_hex_pt_2 = self.shader_hex[4:8][::-1].hex()
+        shader_hex_pt_3 = self.shader_hex[8:12][::-1].hex()
+        shader_hex_pt_4 = self.shader_hex[12:16][::-1].hex()
+
+        self.shader_hex = '_'.join((shader_hex_pt_1, shader_hex_pt_2, shader_hex_pt_3, shader_hex_pt_4))
+
+    def reinterpret_material(self):
+        self.shader_hex: str
+        hex_parts = self.shader_hex.split('_')
+        shader_hex_pt_1 = bytes.fromhex(hex_parts[0])[::-1]
+        shader_hex_pt_2 = bytes.fromhex(hex_parts[1])[::-1]
+        shader_hex_pt_3 = bytes.fromhex(hex_parts[2])[::-1]
+        shader_hex_pt_4 = bytes.fromhex(hex_parts[3])[::-1]
+
+        self.shader_hex = b''.join((shader_hex_pt_1, shader_hex_pt_2, shader_hex_pt_3, shader_hex_pt_4))
+
+
+def byte_to_hexstring(byteval):
+    return '{:02d}'.format(int(hex(byteval)))
+
+
+def hexstring_to_byte(byteval):
+    return '{:02d}'.format(int(hex(byteval)))
+
 
 class MaterialComponent(BaseRW):
     component_types = {