diff --git a/BlenderExtensions/ContextMenu.py b/BlenderExtensions/ContextMenu.py
index de9b337..cea9809 100644
--- a/BlenderExtensions/ContextMenu.py
+++ b/BlenderExtensions/ContextMenu.py
@@ -128,7 +128,7 @@ def execute(self, context):
             # Create a new sphere for collisions
             mesh = bpy.data.meshes.new('sphere')
             bm = bmesh.new()
-            bmesh.ops.create_icosphere(bm, subdivisions=4, radius=0.5)
+            bmesh.ops.create_icosphere(bm, subdivisions=4, radius=1)
             bm.to_mesh(mesh)
             bm.free()
             sphere = bpy.data.objects.new('sphere', mesh)
@@ -163,7 +163,7 @@ def execute(self, context):
             mesh = bpy.data.meshes.new('cylinder')
             bm = bmesh.new()
             bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=True,
-                                  radius1=0.5, radius2=0.5, depth=1.0,
+                                  radius1=1, radius2=1, depth=1.0,
                                   segments=20, matrix=CONE_ROTATION_MAT)
             bm.to_mesh(mesh)
             bm.free()
diff --git a/BlenderExtensions/EntityPanels.py b/BlenderExtensions/EntityPanels.py
index 891dadb..bfe1d08 100644
--- a/BlenderExtensions/EntityPanels.py
+++ b/BlenderExtensions/EntityPanels.py
@@ -567,12 +567,18 @@ class NMS_GcInteractionType_Properties(bpy.types.PropertyGroup):
 
 class NMS_Vector4f_Properties(bpy.types.PropertyGroup):
     """ Properties for Vector4f """
-    x: FloatProperty(name="x")
-    y: FloatProperty(name="y")
-    z: FloatProperty(name="z")
-    t: FloatProperty(name="t")
-
-
+    x: FloatProperty(name="X")
+    y: FloatProperty(name="Y")
+    z: FloatProperty(name="Z")
+    t: FloatProperty(name="W")
+
+class NMS_Vector4i_Properties(bpy.types.PropertyGroup):
+    """ Properties for Vector4i """
+    x: IntProperty(name="X")
+    y: IntProperty(name="Y")
+    z: IntProperty(name="Z")
+    t: IntProperty(name="W")
+    
 class NMS_TkCameraWanderData_Properties(bpy.types.PropertyGroup):
     """ Properties for TkCameraWanderData """
     CamWander: BoolProperty(name="CamWander")
@@ -1048,10 +1054,10 @@ def GcInteractionComponentData(self, layout, obj):
         b2 = b1.box("Camera")
         b2.row("Distance")
         b3 = b2.box("Offset")
-        b3.row("x")
-        b3.row("y")
-        b3.row("z")
-        b3.row("t")
+        b3.row("X")
+        b3.row("Y")
+        b3.row("Z")
+        b3.row("W")
         b2.row("Pitch")
         b2.row("Rotate")
         b2.row("LightPitch")
@@ -1120,10 +1126,10 @@ def TkModelRendererData(self, layout, obj, index=0):
         b1 = r.box("Camera")
         b1.row("Distance")
         b2 = b1.box("Offset")
-        b2.row("x")
-        b2.row("y")
-        b2.row("z")
-        b2.row("t")
+        b2.row("X")
+        b2.row("Y")
+        b2.row("Z")
+        b2.row("W")
         b1.row("Pitch")
         b1.row("Rotate")
         b1.row("LightPitch")
@@ -1366,6 +1372,7 @@ def get_index(self, obj):
            NMS_GcSpaceshipComponentData_Properties,
            NMS_TkCameraWanderData_Properties,
            NMS_Vector4f_Properties,
+           NMS_Vector4i_Properties,
            NMS_TkModelRendererCameraData_Properties,
            NMS_GcAlienPuzzleMissionOverride_Properties,
            NMS_TkModelRendererData_Properties,
diff --git a/BlenderExtensions/NMSShaderNode.py b/BlenderExtensions/NMSShaderNode.py
index d0276c4..f6b59a7 100644
--- a/BlenderExtensions/NMSShaderNode.py
+++ b/BlenderExtensions/NMSShaderNode.py
@@ -12,8 +12,8 @@
 
 FLAGS = [('_F01_DIFFUSEMAP', 'Diffuse Map', 'Diffuse Map'),
          ('_F03_NORMALMAP', 'Normal Map', 'Normal Map'),
-         ('_F21_VERTEXCOLOUR', 'Vertex Colour', 'Vertex Colour'),
-         ('_F25_ROUGHNESS_MASK', 'Roughness Mask', 'Roughness Mask')]
+         ('_F21_VERTEXCUSTOM', 'Vertex Custom', 'Vertex Custom'),
+         ('_F25_MASKS_MAP', 'Masks Map', 'Masks Map')]
 
 
 class NMSShader(bpy.types.NodeCustomGroup):
@@ -27,8 +27,8 @@ def operators(self, context):
         context.space_data.edit_tree
         list = [('_F01_DIFFUSEMAP', 'Diffuse Map', 'Diffuse Map'),
                 ('_F03_NORMALMAP', 'Normal Map', 'Normal Map'),
-                ('_F21_VERTEXCOLOUR', 'Vertex Colour', 'Vertex Colour'),
-                ('_F25_ROUGHNESS_MASK', 'Roughness Mask', 'Roughness Mask')]
+                ('_F21_VERTEXCUSTOM', 'Vertex Custom', 'Vertex Custom'),
+                ('_F25_MASKS_MAP', 'Masks Map', 'Masks Map')]
         return list
 
     # Manage the internal nodes to perform the chained operation - clear all
@@ -38,7 +38,7 @@ def __nodetree_setup__(self):
 
         if self.F01_DIFFUSEMAP_choice:
             diffuse_texture = self._add_diffuse_texture_choice()
-            if self.F21_VERTEXCOLOUR_choice:
+            if self.F21_VERTEXCUSTOM_choice:
                 self._add_vertex_colour_nodes()
             else:
                 self._remove_vertex_colour_nodes()
@@ -111,14 +111,14 @@ def update_nodes(self, context):
         description='Whether material has a normal map.',
         default=False,
         update=update_nodes)
-    F21_VERTEXCOLOUR_choice: BoolProperty(
-        name='Has vertex colour data',
-        description='Whether the material has vertex colour data.',
+    F21_VERTEXCUSTOM_choice: BoolProperty(
+        name='Has vertex custom data',
+        description='Whether the material has vertex custom data.',
         default=False,
         update=update_nodes)
-    F25_ROUGHNESS_MASK_choice: BoolProperty(
-        name='Has roughness mask',
-        description='Whether material has a roughness mask.',
+    F25_MASKS_MAP_choice: BoolProperty(
+        name='Has masks map',
+        description='Whether material has a masks map.',
         default=False,
         update=update_nodes)
 
@@ -150,9 +150,9 @@ def draw_buttons(self, context, layout):
         row = layout.row()
         row.prop(self, 'F03_NORMALMAP_choice', text='Normal Map')
         row = layout.row()
-        row.prop(self, 'F21_VERTEXCOLOUR_choice', text='Vertex Colour')
+        row.prop(self, 'F21_VERTEXCUSTOM_choice', text='Vertex Custom')
         row = layout.row()
-        row.prop(self, 'F25_ROUGHNESS_MASK_choice', text='Roughness Mask')
+        row.prop(self, 'F25_MASKS_MAP_choice', text='Masks Map')
 
     # Copy
     def copy(self, node):
diff --git a/ModelExporter/addon_script.py b/ModelExporter/addon_script.py
index 65c8aab..1d36bf4 100644
--- a/ModelExporter/addon_script.py
+++ b/ModelExporter/addon_script.py
@@ -17,11 +17,11 @@
 from ModelExporter.animations import process_anims
 from ModelExporter.export import Export
 from ModelExporter.Descriptor import Descriptor
-from NMS.classes import (TkMaterialData, TkMaterialFlags,
-                           TkVolumeTriggerType, TkMaterialSampler,
-                           TkMaterialUniform, TkRotationComponentData, TkPhysicsComponentData)
+from NMS.classes import (TkMaterialData, TkMaterialFlags, TkVolumeTriggerType,
+                           TkMaterialSampler, TkMaterialUniform_Float, TkMaterialUniform_UInt,
+                           TkRotationComponentData, TkPhysicsComponentData)
 from NMS.classes import TkAnimationComponentData, TkAnimationData
-from NMS.classes import List, Vector4f
+from NMS.classes import List, Vector4f, Vector4i
 from NMS.classes import TkAttachmentData
 from NMS.classes.Object import Object, Model, Mesh, Locator, Reference, Collision, Light, Joint
 from NMS.LOOKUPS import MATERIALFLAGS
@@ -165,7 +165,7 @@ def create_sampler(image, sampler_name: str, texture_dir: str,
 
     if op.exists(out_tex_path) and not force_overwrite:
         print(f'Found existing texture at {out_tex_path}. Using this.')
-        return TkMaterialSampler(Name=sampler_name, Map=relpath, IsSRGB=True)
+        return TkMaterialSampler(Name=sampler_name, Map=relpath, IsSRGB=False)
 
     # If the textures are packed into the blend file, unpack them.
     if len(image.packed_files) > 0:
@@ -181,7 +181,7 @@ def create_sampler(image, sampler_name: str, texture_dir: str,
         tex_path = image.filepath_from_user()
         shutil.copy(tex_path, out_tex_path)
     if op.exists(out_tex_path):
-        return TkMaterialSampler(Name=sampler_name, Map=relpath, IsSRGB=True)
+        return TkMaterialSampler(Name=sampler_name, Map=relpath, IsSRGB=False)
     else:
         raise FileNotFoundError(f'Texture not written to {out_tex_path}')
 
@@ -404,26 +404,36 @@ def parse_material(self, ob):
                     "label for the diffuse texture, etc.")
 
             # Fetch Uniforms
-            matuniforms.append(TkMaterialUniform(Name="gMaterialColourVec4",
-                                                 Values=Vector4f(x=1.0,
-                                                                 y=1.0,
-                                                                 z=1.0,
-                                                                 t=1.0)))
-            matuniforms.append(TkMaterialUniform(Name="gMaterialParamsVec4",
-                                                 Values=Vector4f(x=1.0,
-                                                                 y=0.5,
-                                                                 z=1.0,
-                                                                 t=0.0)))
-            matuniforms.append(TkMaterialUniform(Name="gMaterialSFXVec4",
-                                                 Values=Vector4f(x=0.0,
-                                                                 y=0.0,
-                                                                 z=0.0,
-                                                                 t=0.0)))
-            matuniforms.append(TkMaterialUniform(Name="gMaterialSFXColVec4",
-                                                 Values=Vector4f(x=0.0,
-                                                                 y=0.0,
-                                                                 z=0.0,
-                                                                 t=0.0)))
+            matuniforms.append(TkMaterialUniform_Float(Name="gMaterialColourVec4",
+                                                 Values=Vector4f(X=1.000000,
+                                                                 Y=1.000000,
+                                                                 Z=1.000000,
+                                                                 W=1.000000)))
+            matuniforms.append(TkMaterialUniform_Float(Name="gMaterialParamsVec4",
+                                                 Values=Vector4f(X=1.000000,
+                                                                 Y=0.500000,
+                                                                 Z=1.000000,
+                                                                 W=0.000000)))
+            matuniforms.append(TkMaterialUniform_Float(Name="gMaterialParams2Vec4",
+                                                 Values=Vector4f(X=1.000000,
+                                                                 Y=0.500000,
+                                                                 Z=1.000000,
+                                                                 W=0.000000)))
+            matuniforms.append(TkMaterialUniform_Float(Name="gMaterialSFXVec4",
+                                                 Values=Vector4f(X=0.000000,
+                                                                 Y=0.000000,
+                                                                 Z=0.000000,
+                                                                 W=0.000000)))
+            matuniforms.append(TkMaterialUniform_Float(Name="gMaterialSFXColVec4",
+                                                 Values=Vector4f(X=0.000000,
+                                                                 Y=0.000000,
+                                                                 Z=0.000000,
+                                                                 W=0.000000)))
+            matuniforms.append(TkMaterialUniform_UInt(Name="gDynamicFlags",
+                                                 Values=Vector4i(X=3,
+                                                                 Y=0,
+                                                                 Z=0,
+                                                                 W=0)))
 
             if self.settings.get('use_shared_textures'):
                 texture_dir = self.settings.get('shared_texture_folder')
@@ -451,10 +461,8 @@ def parse_material(self, ob):
 
             # Sort out Mask
             if mask_image:
-                # Set _F25_ROUGHNESS_MASK
+                # Set _F25_MASKS_MAP
                 add_matflags.add(24)
-                # Set _F39_METALLIC_MASK
-                add_matflags.add(38)
                 # Add the sampler to the list
                 matsamplers.append(create_sampler(
                     mask_image, "gMasksMap", texture_dir,
@@ -686,7 +694,7 @@ def mesh_parser(self, ob, is_coll_mesh: bool = False):
                     uv = uv_layer_data[li].uv
                     uvs[vi] = (uv[0], 1 - uv[1], 0, 1)
                 else:
-                    # Calculate the ev value to write then compare it to what
+                    # Calculate the uv value to write then compare it to what
                     # we have already to see if we need to split the vert.
                     uv = uv_layer_data[li].uv
                     uv = (uv[0], 1 - uv[1], 0, 1)
diff --git a/ModelExporter/export.py b/ModelExporter/export.py
index a330522..cdde485 100644
--- a/ModelExporter/export.py
+++ b/ModelExporter/export.py
@@ -22,8 +22,8 @@
 import struct
 from itertools import accumulate
 # Internal imports
-from NMS.classes import TkAttachmentData, TkGeometryData
-from NMS.LOOKUPS import SEMANTICS, REV_SEMANTICS, STRIDES
+from NMS.classes import TkAttachmentData
+from NMS.LOOKUPS import SEMANTICS, REV_SEMANTICS, STRIDES, VERTS
 from NMS.classes.Object import Model
 from serialization.NMS_Structures import MBINHeader
 from serialization.NMS_Structures.Structures import (
@@ -32,10 +32,8 @@
 from serialization.NMS_Structures.Structures import (
     TkGeometryData as TkGeometryData_new,
 )
-from serialization.mbincompiler import mbinCompiler
 from serialization.StreamCompiler import StreamData
-from serialization.serializers import (serialize_index_stream,
-                                         serialize_vertex_stream)
+from serialization.serializers import serialize_vertex_stream
 from ModelExporter.utils import nmsHash, traverse
 
 
@@ -98,7 +96,7 @@ def __init__(self, export_directory, scene_directory, scene_name, model: Model,
         # unique TkMaterialData struct in the set
         self.materials = set()
         self.hashes = odict()
-        self.mesh_names = list()
+        self.mesh_names: list[str] = list()
 
         self.np_index_data = np.array([], dtype=np.uint32)
 
@@ -187,7 +185,7 @@ def __init__(self, export_directory, scene_directory, scene_name, model: Model,
 
         self.get_bounds()
 
-        # this creates the VertexLayout and SmallVertexLayout properties
+        # this creates the VertexLayout and PositionVertexLayout properties
         self.create_vertex_layouts()
 
         self.process_nodes()
@@ -195,13 +193,6 @@ def __init__(self, export_directory, scene_directory, scene_name, model: Model,
         # other data.
         self.mix_streams()
 
-        # Assign each of the class objects that contain all of the data their
-        # data
-        # if (not self.preserve_node_info
-        #         or (self.preserve_node_info
-        #             and self.export_original_geom_data)):
-        #     self.TkGeometryData = TkGeometryData(**self.GeometryData)
-        #     self.TkGeometryData.make_elements(main=True)
         self.Model.construct_data()
         self.TkSceneNodeData = self.Model.get_data()
         for material in self.materials:
@@ -245,14 +236,15 @@ def preprocess_streams(self):
                           'provided for {} Object'.format(mesh.Name))
 
         self.stream_list = list(
-            SEMANTICS[x] for x in streams.difference({'Indexes'}))
+            SEMANTICS[x] for x in streams.difference({'Indexes', 'Vertices'}))
         self.stream_list.sort()
 
         self.element_count = len(self.stream_list)
         # Create a list to store the offset sizes for each data type
         offsets = list()
         for sid in self.stream_list:
-            offsets.append(STRIDES[sid])
+            if sid != VERTS:
+                offsets.append(STRIDES[sid])
         # Now create an ordered dictionary. Each kvp is the sid and the actual
         # offset as calculated by the sum of all the entries before it.
         self.offsets = odict()
@@ -277,43 +269,45 @@ def serialize_data(self):
         convert all the provided vertex and index data to bytes to be passed
         directly to the gstream and geometry file constructors
         """
-        vertex_data = []
         vertex_sizes = []
+        vertex_pos_sizes = []
         index_sizes = []
         mesh_datas: list[TkMeshData] = []
         for i, name in enumerate(self.mesh_names):
+            count = len(self.vertex_stream[name])
             v_data = serialize_vertex_stream(
                 requires=self.stream_list,
-                Vertices=self.vertex_stream[name],
+                count=count,
                 UVs=self.uv_stream[name],
                 Normals=self.n_stream[name],
                 Tangents=self.t_stream[name],
                 Colours=self.c_stream[name]
             )
+            v_pos_data = serialize_vertex_stream(
+                requires={SEMANTICS["Vertices"]},
+                count=count,
+                Vertices=self.vertex_stream[name],
+            )
             v_len = len(v_data)
-            vertex_data.append(v_data)
             vertex_sizes.append(v_len)
-            # new_indexes = self.index_stream[name]
-            # # TODO: serialize the same way as they are in the actual data.
-            # # This will also fail I think if there are indexes > 0xFFFF since it will serialize some as H and
-            # # some as I
-            # if max(new_indexes) > 2 ** 16:
-            #     indexes = array('I', new_indexes)
-            # else:
-            #     indexes = array('H', new_indexes)
-            # i_data = serialize_index_stream(indexes)
+            v_pos_len = len(v_pos_data)
+            vertex_pos_sizes.append(v_pos_len)
             i_data = self.np_indexes[i]
-            if self.Indices16Bit:
-                i_data = i_data.astype(np.uint16)
-            i_data = i_data.tobytes()
+            # Depending on how many verts there are, we will need to serialize the indexes differently.
+            if max(i_data) > 0xFFFF:
+                i_data = i_data.astype(np.uint32).tobytes()
+            else:
+                i_data = i_data.astype(np.uint16).tobytes()
             i_len = len(i_data)
             index_sizes.append(i_len)
             md = TkMeshData(
                 name.upper(),
                 v_data + i_data,
+                v_pos_data,
                 self.mesh_metadata[name]["hash"],
                 i_len,
-                v_len
+                v_len,
+                v_pos_len,
             )
             mesh_datas.append(md)
         gstream_data = TkGeometryStreamData(mesh_datas)
@@ -321,27 +315,41 @@ def serialize_data(self):
         with open(self.gstream_fpath, "wb") as f:
             hdr = MBINHeader()
             hdr.header_namehash = 0x40025754
-            hdr.header_guid = 0x1D6CC846AC06B54C
+            hdr.header_guid = 0xCCB46895A8B36313
             hdr.write(f)
             gstream_data.write(f)
 
+        # This is a list of 3-tuples with the structure (vert_offset, index_offset_vert_pos_offset)
         offsets = []
 
         # A bit of a hack, but we need the offsets of the index and vert data. We'll use this code to get it
         # since it works.
         with open(self.gstream_fpath, "rb") as f:
+            # Read the number of TkMeshData's serialized.
             f.seek(0x28, 0)
             entries = struct.unpack("<I", f.read(4))[0]
 
+            TkMeshData_size = 0x48
+
+            # Then jump to the start of these.
             f.seek(0x30, 0)
             for i in range(entries):
-                f.seek(0x10, 1)
+                entry_start = f.tell()
+                # First read the list header for MeshDataStream
+                f.seek(entry_start + 0x10, 0)
                 curr_pos = f.tell()
                 offset = struct.unpack("<Q", f.read(8))[0]
-                abs_pos = curr_pos + offset
-                f.seek(0x10, 1)
-                _, vert_size = struct.unpack("<II", f.read(8))
-                offsets.append((abs_pos, abs_pos + vert_size))
+                vert_data_pos = curr_pos + offset
+                f.seek(entry_start + 0x20, 0)
+                curr_pos = f.tell()
+                offset = struct.unpack("<Q", f.read(8))[0]
+                vert_pos_data_pos = curr_pos + offset
+                # To get the index start, we just need to get the size of the vertex data and add it to the
+                # start address of the vertex data since it's serialized in the same data.
+                f.seek(entry_start + 0x3C, 0)
+                vert_size = struct.unpack("<I", f.read(4))[0]
+                offsets.append((vert_data_pos, vert_data_pos + vert_size, vert_pos_data_pos))
+                f.seek(entry_start + TkMeshData_size, 0)
 
         # while we are here we will generate the mesh metadata for the geometry
         # file.
@@ -349,13 +357,15 @@ def serialize_data(self):
         StreamMetaDataArray = []
         for i, md in enumerate(mesh_datas):
             StreamMetaDataArray.append(TkMeshMetaData(
-                md.IdString.upper(),
-                md.Hash,
-                offsets[i][1],
-                index_sizes[i],
-                offsets[i][0],
-                vertex_sizes[i],
-                False
+                IdString=md.IdString.upper(),
+                Hash=md.Hash,
+                IndexDataOffset=offsets[i][1],
+                IndexDataSize=index_sizes[i],
+                VertexDataOffset=offsets[i][0],
+                VertexDataSize=vertex_sizes[i],
+                VertexPositionDataOffset=offsets[i][2],
+                VertexPositionDataSize=vertex_pos_sizes[i],
+                DoubleBufferGeometry=False,
             ))
             # metadata = {
             #     'ID': m.ID, 'hash': m.hash, 'vert_size': m.vertex_size,
@@ -515,12 +525,12 @@ def process_nodes(self):
                 data['BOUNDHULLED'] = self.hull_bounds[name][1]
                 if mesh_obj._Type == 'MESH':
                     # add the AABBMIN/MAX(XYZ) values:
-                    data['AABBMINX'] = self.mesh_bounds[name]['x'][0]
-                    data['AABBMINY'] = self.mesh_bounds[name]['y'][0]
-                    data['AABBMINZ'] = self.mesh_bounds[name]['z'][0]
-                    data['AABBMAXX'] = self.mesh_bounds[name]['x'][1]
-                    data['AABBMAXY'] = self.mesh_bounds[name]['y'][1]
-                    data['AABBMAXZ'] = self.mesh_bounds[name]['z'][1]
+                    data['AABBMINX'] = self.mesh_bounds[name]['X'][0]
+                    data['AABBMINY'] = self.mesh_bounds[name]['Y'][0]
+                    data['AABBMINZ'] = self.mesh_bounds[name]['Z'][0]
+                    data['AABBMAXX'] = self.mesh_bounds[name]['X'][1]
+                    data['AABBMAXY'] = self.mesh_bounds[name]['Y'][1]
+                    data['AABBMAXZ'] = self.mesh_bounds[name]['Z'][1]
                     data['HASH'] = self.hashes.get(name, 0)
                     # we only care about entity and material data for Mesh
                     # Objects
@@ -558,11 +568,15 @@ def process_nodes(self):
                                                  ent_path)))
                         else:
                             data['ATTACHMENT'] = obj.EntityPath
+                    # TODO: Do we even need to add this mesh metadata?
                     # enerate the mesh metadata for the geometry file:
                     self.mesh_metadata[name]['Hash'] = data['HASH']
-                    self.mesh_metadata[name]['VertexDataSize'] = (
-                        self.stride * (
-                            data['VERTREND'] - data['VERTRSTART'] + 1))
+                    self.mesh_metadata[name]['VertexDataSize'] = self.stride * (
+                        data['VERTREND'] - data['VERTRSTART'] + 1
+                    )
+                    self.mesh_metadata[name]['VertexPositionDataSize'] = STRIDES[VERTS] * (
+                        data['VERTREND'] - data['VERTRSTART'] + 1
+                    )
                     if self.GeometryData['Indices16Bit'] == 0:
                         m = 4
                     else:
@@ -617,10 +631,19 @@ def process_nodes(self):
     def create_vertex_layouts(self):
         # sort out what streams are given and create appropriate vertex layouts
         VertexElements = []
-        SmallVertexElements = []
+        PositionVertexElements = [
+            TkVertexElement(
+                SemanticID=VERTS,
+                Size=4,
+                Type=5131,
+                Offset=0,
+                Normalise=0,
+                Instancing=0
+            )
+        ]
         for sID in self.stream_list:
             # sID is the SemanticID
-            if sID in [0, 1]:
+            if sID == 1:
                 Offset = self.offsets[sID]
                 VertexElements.append(TkVertexElement(SemanticID=sID,
                                                       Size=4,
@@ -628,15 +651,7 @@ def create_vertex_layouts(self):
                                                       Offset=Offset,
                                                       Normalise=0,
                                                       Instancing=0))
-                # Also write the small vertex data
-                Offset = 8 * sID
-                SmallVertexElements.append(
-                    TkVertexElement(SemanticID=sID,
-                                    Size=4,
-                                    Type=5131,
-                                    Offset=Offset,
-                                    Normalise=0,
-                                    Instancing=0))
+
             # for the INT_2_10_10_10_REV stuff
             elif sID in [2, 3]:
                 Offset = self.offsets[sID]
@@ -661,46 +676,14 @@ def create_vertex_layouts(self):
             PlatformData=0,
             VertexElements=VertexElements,
         )
-        # TODO: do more generically
-        self.GeometryData['SmallVertexLayout'] = TkVertexLayout(
-            ElementCount=len(SmallVertexElements),
-            Stride=0x8 * len(SmallVertexElements),
+        self.GeometryData['PositionVertexLayout'] = TkVertexLayout(
+            ElementCount=len(PositionVertexElements),
+            Stride=0x8 * len(PositionVertexElements),
             PlatformData=0,
-            VertexElements=SmallVertexElements,
+            VertexElements=PositionVertexElements,
         )
 
     def mix_streams(self):
-        # this combines all the input streams into one single stream with the
-        # correct offset etc as specified by the VertexLayout
-        # This also flattens each stream so it needs to be called pretty much
-        # last
-
-        VertexStream = array('f')
-        SmallVertexStream = array('f')
-        for name, mesh_obj in self.Model.Meshes.items():
-            for j in range(self.v_stream_lens[name]):
-                for sID in self.stream_list:
-                    # get the j^th 4Vector element of i^th object of the
-                    # corresponding stream as specified by the stream list.
-                    # As self.stream_list is ordered this will be mixed in the
-                    # correct way wrt. the VertexLayouts
-                    try:
-                        VertexStream.extend(
-                            mesh_obj.__dict__[REV_SEMANTICS[sID]][j])
-                        if sID in [0, 1]:
-                            SmallVertexStream.extend(
-                                mesh_obj.__dict__[REV_SEMANTICS[sID]][j])
-                    except IndexError:
-                        # in the case this fails there is an index error caused
-                        # by collisions. In this case just add a default value
-                        VertexStream.extend((0, 0, 0, 1))
-                    except TypeError:
-                        print(f'{name} mesh has an error!')
-                        raise
-
-        self.GeometryData['VertexStream'] = VertexStream
-        self.GeometryData['SmallVertexStream'] = SmallVertexStream
-
         # Handle the index streams.
         # First, we create a list which contains the cumulative count, and then we add this value to each
         # array.
@@ -748,8 +731,8 @@ def get_bounds(self):
             self.GeometryData['MeshAABBMax'].append((x_bounds[1], y_bounds[1], z_bounds[1], 1))
             if obj._Type == "MESH":
                 # only add the meshes to the self.mesh_bounds dict:
-                self.mesh_bounds[obj.Name] = {'x': x_bounds, 'y': y_bounds,
-                                              'z': z_bounds}
+                self.mesh_bounds[obj.Name] = {'X': x_bounds, 'Y': y_bounds,
+                                              'Z': z_bounds}
 
     # TODO: Change this here too...
     def write(self):
@@ -768,35 +751,35 @@ def write(self):
                 hdr = MBINHeader(
                     header_magic = 0xDDDDDDDDDDDDDDDD,
                     header_namehash = 0x819C3220,
-                    header_guid = 0x32F6AE7B03222A1F,
+                    header_guid = 0xDA1F6CA99ADEF6A6,
                     header_timestamp = 0xFFFFFFFFFFFFFFFF,
                 )
                 hdr.write(f)
                 gd = self.GeometryData
                 thing = TkGeometryData_new(
-                    SmallVertexLayout=gd["SmallVertexLayout"],  # good
-                    VertexLayout=gd["VertexLayout"],  # good
-                    BoundHullVertEd=gd["BoundHullVertEd"],  # good
-                    BoundHullVerts=gd["BoundHullVerts"],  # good
-                    BoundHullVertSt=gd["BoundHullVertSt"],  # good
+                    PositionVertexLayout=gd["PositionVertexLayout"],
+                    VertexLayout=gd["VertexLayout"],
+                    BoundHullVertEd=gd["BoundHullVertEd"],
+                    BoundHullVerts=gd["BoundHullVerts"],
+                    BoundHullVertSt=gd["BoundHullVertSt"],
                     IndexBuffer=gd["IndexBuffer"],
                     JointBindings=[],
                     JointExtents=[],
                     JointMirrorAxes=[],
                     JointMirrorPairs=[],
-                    MeshAABBMax=gd["MeshAABBMax"],  # good
-                    MeshAABBMin=gd["MeshAABBMin"],  # good
+                    MeshAABBMax=gd["MeshAABBMax"],
+                    MeshAABBMin=gd["MeshAABBMin"],
                     MeshBaseSkinMat=[],
-                    MeshVertREnd=gd["MeshVertREnd"],  # good
-                    MeshVertRStart=gd["MeshVertRStart"],  # good
+                    MeshVertREnd=gd["MeshVertREnd"],
+                    MeshVertRStart=gd["MeshVertRStart"],
                     ProcGenNodeNames=[],
                     ProcGenParentId=[],
                     SkinMatrixLayout=[],
-                    StreamMetaDataArray=gd["StreamMetaDataArray"],  # good
-                    CollisionIndexCount=gd["CollisionIndexCount"],  # good
-                    IndexCount=gd["IndexCount"],  # good
-                    Indices16Bit=self.Indices16Bit,  # good
-                    VertexCount=gd["VertexCount"],  # good
+                    StreamMetaDataArray=gd["StreamMetaDataArray"],
+                    CollisionIndexCount=gd["CollisionIndexCount"],
+                    IndexCount=gd["IndexCount"],
+                    Indices16Bit=self.Indices16Bit,
+                    VertexCount=gd["VertexCount"],
                 )
                 thing.write(f)
 
@@ -804,7 +787,7 @@ def write(self):
         with open(scene_path, "wb") as f:
             hdr = MBINHeader()
             hdr.header_namehash = 0x3DB87E47
-            hdr.header_guid = 0x6A9DE02E8902AAC3
+            hdr.header_guid = 0x42A57794F683F216
             hdr.write(f)
             self.TkSceneNodeData.write(f)
         print(f'Scene written to {scene_path}')
diff --git a/ModelImporter/animation_handler.py b/ModelImporter/animation_handler.py
index da719a4..42e21d0 100644
--- a/ModelImporter/animation_handler.py
+++ b/ModelImporter/animation_handler.py
@@ -285,9 +285,9 @@ def _create_anim_channels(self, obj, anim_name: str):
         Tuple of collections.namedtuple's:
             (location, rotation, scale)
         """
-        location = namedtuple('location', ['x', 'y', 'z'])
-        rotation = namedtuple('rotation', ['x', 'y', 'z', 'w'])
-        scale = namedtuple('scale', ['x', 'y', 'z'])
+        location = namedtuple('location', ['X', 'Y', 'Z'])
+        rotation = namedtuple('rotation', ['X', 'Y', 'Z', 'W'])
+        scale = namedtuple('scale', ['X', 'Y', 'Z'])
         loc_x = obj.animation_data.action.fcurves.new(data_path='location',
                                                       index=0,
                                                       action_group=anim_name)
diff --git a/ModelImporter/import_scene.py b/ModelImporter/import_scene.py
index e479a85..eebc76d 100644
--- a/ModelImporter/import_scene.py
+++ b/ModelImporter/import_scene.py
@@ -1,12 +1,10 @@
 # stdlib imports
 import time
 import os.path as op
-import struct
 from math import radians
 import subprocess
-from typing import List
+from typing import cast
 import numpy as np
-import itertools
 
 # Blender imports
 import bpy
@@ -16,21 +14,26 @@
 
 # Internal imports
 from serialization.formats import np_read_int_2_10_10_10_rev
-from NMS.LOOKUPS import VERTS, NORMS, UVS, COLOURS, BLENDINDEX, BLENDWEIGHT, REV_SEMANTICS
+from NMS.LOOKUPS import COLOURS, REV_SEMANTICS
 from NMS.material_node import create_material_node
 from ModelImporter.readers import (
-    read_gstream, read_entity_animation_data, read_descriptor, gstream_info
+    read_gstream, read_entity_animation_data, gstream_info
 )
 from ModelImporter.SceneNodeData import SceneNodeData
 from ModelImporter.mesh_utils import BB_transform_matrix
 from utils.io import get_NMS_dir, base_path
 from utils.bpyutils import SceneOp, edit_object, select_object
 
-from serialization.NMS_Structures import TkSceneNodeData, MBINHeader, TkGeometryData, NAMEHASH_MAPPING
+from serialization.NMS_Structures.Structures import (
+    TkSceneNodeData, TkGeometryData, TkModelDescriptorList, NAMEHASH_MAPPING
+)
+from serialization.NMS_Structures.NMS_types import MBINHeader
 
-VERT_TYPE_MAP = {5121: {'size': 1, 'np_fmt': "4B"},
-                 5131: {'size': 2, 'np_fmt': "4e"},
-                 36255: {'size': 1, 'np_fmt': np.int32}}
+VERT_TYPE_MAP = {
+    5121: {'size': 1, 'np_fmt': "4B"},
+    5131: {'size': 2, 'np_fmt': "4e"},
+    36255: {'size': 1, 'np_fmt': np.int32}
+}
 ROT_MATRIX = Matrix.Rotation(radians(90), 4, 'X')
 DATA_PATH_MAP = {'Rotation': 'rotation_quaternion',
                  'Translation': 'location',
@@ -130,22 +133,23 @@ def __init__(self, fpath, parent_obj=None, ref_scenes=dict(),
         self.ref_scenes[self.scene_name] = list()
 
         self.data = None
-        self.vertex_elements = list()
-        self.bh_data = list()
-        self.materials = dict()
+        self.position_vertex_elements = []
+        self.vertex_elements = []
+        self.bh_data = []
+        self.materials = {}
         self.entities = set()
-        self.animations = dict()
+        self.animations = {}
         # This list of joints is used to add all the bones if needed
-        self.joints: List[SceneNodeData] = list()
-        self.skinned_meshes = list()
+        self.joints: list[SceneNodeData] = []
+        self.skinned_meshes = []
         self.mesh_binding_data = None
-        # inverse bind matrices are the global transforms of the joints parent
-        self.inv_bind_matrices = dict()
-        # bind matrices are the local transforms of the intial states of the
+        # Inverse bind matrices are the global transforms of the joints parent
+        self.inv_bind_matrices = {}
+        # Bind matrices are the local transforms of the intial states of the
         # joint itself.
-        self.bind_matrices = dict()
+        self.bind_matrices = {}
 
-        # change to render with cycles
+        # Change to render with cycles
         self.scn.render.engine = RENDER_ENGINE
 
         if not op.exists(mbin_fpath):
@@ -184,7 +188,7 @@ def __init__(self, fpath, parent_obj=None, ref_scenes=dict(),
                 self.PCBANKS_dir,
                 self.scene_node_data.Attribute('GEOMETRY') + '.PC')
 
-        self.descriptor_data = dict()
+        self.descriptor_data = TkModelDescriptorList([])
 
         self.geometry_stream_file = self.geometry_file.replace('GEOMETRY', 'GEOMETRY.DATA')
 
@@ -206,8 +210,19 @@ def __init__(self, fpath, parent_obj=None, ref_scenes=dict(),
             self.mesh_indexes = geometry_data.IndexBuffer
         self.CollisionIndexCount = geometry_data.CollisionIndexCount
         self.Indices16Bit = geometry_data.Indices16Bit
-        self.count = geometry_data.VertexLayout.ElementCount
-        self.stride = geometry_data.VertexLayout.Stride
+        self.vert_pos_count = geometry_data.PositionVertexLayout.ElementCount
+        self.vert_pos_stride = geometry_data.PositionVertexLayout.Stride
+        self.vert_extras_count = geometry_data.VertexLayout.ElementCount
+        self.vert_extras_stride = geometry_data.VertexLayout.Stride
+        for ve in geometry_data.PositionVertexLayout.VertexElements:
+            self.position_vertex_elements.append(
+                {
+                    "semID": ve.SemanticID,
+                    "size": ve.Size,
+                    "type": ve.Type,
+                    "offset": ve.Offset,
+                }
+            )
         for ve in geometry_data.VertexLayout.VertexElements:
             self.vertex_elements.append(
                 {
@@ -235,7 +250,9 @@ def __init__(self, fpath, parent_obj=None, ref_scenes=dict(),
                 x.VertexDataSize,
                 x.VertexDataOffset,
                 x.IndexDataSize,
-                x.IndexDataOffset
+                x.IndexDataOffset,
+                x.VertexPositionDataSize,
+                x.VertexPositionDataOffset,
             )
             for x in geometry_data.StreamMetaDataArray
         }
@@ -598,18 +615,9 @@ def _add_empty_to_scene(self, scene_node: SceneNodeData,
                 print(f'Now trying to find a descriptor at: {descriptor_path}')
             if op.exists(descriptor_path + '.MBIN'):
                 empty_obj.NMSReference_props.is_proc = True
-                # Also convert the .mbin to mxml for parsing if the mxml
-                # doesn't already exist.
-                if not op.exists(descriptor_path + '.MXML'):
-                    retcode = subprocess.call(
-                        [self.scn.nmsdk_default_settings.MBINCompiler_path,
-                         "-q", "-Q", descriptor_path + '.MBIN'])
-                    if retcode != 0:
-                        print('MBINCompiler failed to run. Please ensure it is'
-                              ' registered on the path.')
-                        print('Import failed')
-                        return
-                self.descriptor_data = read_descriptor(descriptor_path + '.MXML')
+                with open(descriptor_path + ".MBIN", 'rb') as f:
+                    MBINHeader.read(f)
+                    self.descriptor_data = TkModelDescriptorList.read(f)
             else:
                 print("No descriptor found... Scene is not proc-gen")
             self.local_objects[self.scene_basename] = empty_obj
@@ -807,7 +815,7 @@ def _add_primitive_collision_to_scene(self, scene_node: SceneNodeData):
                           float(scene_node.Attribute('RADIUS'))]
         elif coll_type == 'Cylinder':
             bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=True,
-                                  radius1=0.5, radius2=0.5, depth=1.0,
+                                  radius1=1, radius2=1, depth=1.0,
                                   segments=20, matrix=ROT_MATRIX)
             scale_mult = [float(scene_node.Attribute('RADIUS')),
                           float(scene_node.Attribute('HEIGHT')),
@@ -1054,17 +1062,18 @@ def _add_mesh_to_scene(self, scene_node: SceneNodeData,
     def _apply_proc_gen_info(self):
         """ Go over the data in the descriptor and add it to the scene. """
         # We'll create a function here to apply recursively
-        def apply_recursively(data, parent_collection):
-            for key, value in data.items():
+        def apply_recursively(data: TkModelDescriptorList, parent_collection):
+            for resource_descriptor_list in data.List:
+                key = resource_descriptor_list.TypeId
                 coll = bpy.data.collections.new(key)
                 parent_collection.children.link(coll)
-                for node in value:
-                    obj = bpy.data.objects.get(node['Name'])
+                for node in resource_descriptor_list.Descriptors:
+                    obj = bpy.data.objects.get(node.Name)
                     if obj:
                         obj.NMSDescriptor_props.choice_types = "Random"
                         obj.NMSDescriptor_props.proc_prefix = key
                         coll.objects.link(obj)
-                    for child in node['Children']:
+                    for child in node.Children:
                         apply_recursively(child, coll)
 
         # Let's add a collection for all the proc-gen object's to be linked in
@@ -1133,7 +1142,17 @@ def _deserialize_vertex_data(self, mesh: SceneNodeData):
             SceneNodeData of type MESH to get the vertex data of.
         """
         names: list[str] = []
+        pos_names: list[str] = []
         np_fmts: list[str] = []
+        np_pos_fmts: list[str] = []
+        for ve in self.position_vertex_elements:
+            _size = ve['size'] * VERT_TYPE_MAP[ve['type']]['size']
+            np_fmt = VERT_TYPE_MAP[ve['type']]['np_fmt']
+            if np_fmt is not None:
+                np_pos_fmts.append(np_fmt)
+            else:
+                np_pos_fmts.append(f"S{_size}")
+            pos_names.append(REV_SEMANTICS[ve['semID']])
         for ve in self.vertex_elements:
             _size = ve['size'] * VERT_TYPE_MAP[ve['type']]['size']
             np_fmt = VERT_TYPE_MAP[ve['type']]['np_fmt']
@@ -1142,17 +1161,25 @@ def _deserialize_vertex_data(self, mesh: SceneNodeData):
             else:
                 np_fmts.append(f"S{_size}")
             names.append(REV_SEMANTICS[ve['semID']])
-        num_verts = mesh.metadata.vert_size / self.stride
+
+        metadata = cast(gstream_info, mesh.metadata)
+
+        num_verts = metadata.vert_size / self.vert_extras_stride
         np_dtype = np.dtype({"names": names, "formats": np_fmts})
+        np_pos_dtype = np.dtype({"names": pos_names, "formats": np_pos_fmts})
         if not num_verts % 1 == 0:
             raise ValueError(f'Error with {mesh.Name}: # of verts '
-                             f'({mesh.metadata.vert_size}) isn\'t consistent '
+                             f'({metadata.vert_size}) isn\'t consistent '
                              'with the stride value.')
 
         with open(self.geometry_stream_file, "rb") as f:
-            vert_data = np.rec.fromfile(f, np_dtype, int(num_verts), offset=mesh.metadata.vert_off)
-            if "Vertices" in names:
-                mesh.np_verts = vert_data.Vertices[:, :3].flatten()
+            vert_data = np.rec.fromfile(f, np_dtype, int(num_verts), offset=metadata.vert_off)
+            # NOTE: Because numpy is whack, offset is the relative offset to the current cursor location.
+            # Go back to the start to make our life easier...
+            f.seek(0)
+            pos_vert_data = np.rec.fromfile(f, np_pos_dtype, int(num_verts), offset=metadata.vert_pos_off)
+            if "Vertices" in pos_names:
+                mesh.np_verts = pos_vert_data.Vertices[:, :3].flatten()
             if "UVs" in names:
                 vert_data.UVs[..., 1] = 1 - vert_data.UVs[..., 1]
                 mesh.np_uvs = vert_data.UVs[:, :2]
diff --git a/ModelImporter/readers.py b/ModelImporter/readers.py
index 5f79ca0..ebf208d 100644
--- a/ModelImporter/readers.py
+++ b/ModelImporter/readers.py
@@ -1,23 +1,23 @@
-from collections import namedtuple
 import struct
-from typing import Tuple
+from typing import Tuple, NamedTuple
 import os.path as op
 
 # TODO: move to the serialization folder?
 
-from serialization.utils import (read_list_header, read_string, # noqa pylint: disable=relative-beyond-top-level
-                                   bytes_to_quat, read_bool, read_uint32,
-                                   returned_read)
-from serialization.list_header import ListHeader  # noqa pylint: disable=relative-beyond-top-level
-from utils.utils import mxml_to_dict  # noqa pylint: disable=relative-beyond-top-level
+from serialization.utils import read_string, bytes_to_quat
+from serialization.list_header import ListHeader
+from utils.utils import mxml_to_dict
 
 from serialization.NMS_Structures import TkMaterialData, MBINHeader, NAMEHASH_MAPPING, TkAnimMetadata
 
 
-gstream_info = namedtuple(
-    'gstream_info',
-    ['vert_size', 'vert_off', 'idx_size', 'idx_off']
-)
+class gstream_info(NamedTuple):
+    vert_size: int
+    vert_off: int
+    idx_size: int
+    idx_off: int
+    vert_pos_size: int
+    vert_pos_off: int
 
 
 def read_anim(fname):  # TODO: FIX!
@@ -152,11 +152,11 @@ def read_material(fname):
     if not op.exists(fname):
         return None
     with open(fname, "rb") as f:
-        header = MBINHeader.read(f)
+        MBINHeader.read(f)
         return TkMaterialData.read(f)
 
 
-def read_gstream(fname: str, info: namedtuple) -> Tuple[bytes, bytes]:
+def read_gstream(fname: str, info: gstream_info) -> Tuple[bytes, bytes]:
     """ Read the requested info from the gstream file.
 
     Parameters
diff --git a/NMS/LOOKUPS.py b/NMS/LOOKUPS.py
index 2a38b2e..eb6e402 100644
--- a/NMS/LOOKUPS.py
+++ b/NMS/LOOKUPS.py
@@ -3,31 +3,21 @@
 import numpy as np
 
 
-MATERIALFLAGS = ['_F01_DIFFUSEMAP', '_F02_SKINNED', '_F03_NORMALMAP', '_F04_',
-                 '_F05_INVERT_ALPHA', '_F06_BRIGHT_EDGE', '_F07_UNLIT',
-                 '_F08_REFLECTIVE', '_F09_TRANSPARENT', '_F10_NORECEIVESHADOW',
-                 '_F11_ALPHACUTOUT', '_F12_BATCHED_BILLBOARD',
-                 '_F13_UVANIMATION', '_F14_UVSCROLL', '_F15_WIND',
-                 '_F16_DIFFUSE2MAP', '_F17_MULTIPLYDIFFUSE2MAP',
-                 '_F18_UVTILES', '_F19_BILLBOARD', '_F20_PARALLAXMAP',
-                 '_F21_VERTEXCOLOUR', '_F22_TRANSPARENT_SCALAR',
-                 '_F23_TRANSLUCENT', '_F24_AOMAP', '_F25_ROUGHNESS_MASK',
-                 '_F26_STRETCHY_PARTICLE', '_F27_VBTANGENT', '_F28_VBSKINNED',
-                 '_F29_VBCOLOUR', '_F30_REFRACTION', '_F31_DISPLACEMENT',
-                 '_F32_REFRACTION_MASK', '_F33_SHELLS', '_F34_GLOW',
-                 '_F35_GLOW_MASK', '_F36_DOUBLESIDED', '_F37_',
-                 '_F38_NO_DEFORM', '_F39_METALLIC_MASK',
-                 '_F40_SUBSURFACE_MASK', '_F41_DETAIL_DIFFUSE',
-                 '_F42_DETAIL_NORMAL', '_F43_NORMAL_TILING', '_F44_IMPOSTER',
-                 '_F45_VERTEX_BLEND', '_F46_BILLBOARD_AT',
-                 '_F47_REFLECTION_PROBE', '_F48_WARPED_DIFFUSE_LIGHTING',
-                 '_F49_DISABLE_AMBIENT', '_F50_DISABLE_POSTPROCESS',
-                 '_F51_DECAL_DIFFUSE', '_F52_DECAL_NORMAL',
-                 '_F53_COLOURISABLE', '_F54_COLOURMASK', '_F55_MULTITEXTURE',
-                 '_F56_MATCH_GROUND', '_F57_DETAIL_OVERLAY',
-                 '_F58_USE_CENTRAL_NORMAL', '_F59_SCREENSPACE_FADE',
-                 '_F60_ACUTE_ANGLE_FADE', '_F61_CLAMP_AMBIENT',
-                 '_F62_DETAIL_ALPHACUTOUT', '_F63_DISSOLVE', '_F64_']
+MATERIALFLAGS = ['_F01_DIFFUSEMAP', '_F02_SKINNED', '_F03_NORMALMAP', '_F04_FEATURESMAP',
+                 '_F05_DEPTH_EFFECT', '_F06_', '_F07_UNLIT', '_F08_', '_F09_REFLECTIVE',
+                 '_F10_', '_F11_ALPHACUTOUT', '_F12_BATCHED_BILLBOARD', '_F13_UV_EFFECT',
+                 '_F14_', '_F15_WIND', '_F16_DIFFUSE2MAP', '_F17_', '_F18_',
+                 '_F19_BILLBOARD', '_F20_PARALLAX', '_F21_VERTEXCUSTOM',
+                 '_F22_OCCLUSION_MAP', '_F23_', '_F24_', '_F25_MASKS_MAP', '_F26_', '_F27_',
+                 '_F28_', '_F29_', '_F30_REFRACTION', '_F31_DISPLACEMENT',
+                 '_F32_REFRACTION_MASK', '_F33_SHELLS', '_F34_', '_F35_', '_F36_DOUBLESIDED',
+                 '_F37_EXPLICIT_MOTION_VECTORS', '_F38_', '_F39_', '_F40_', '_F41_',
+                 '_F42_DETAIL_NORMAL', '_F43_', '_F44_IMPOSTER', '_F45_', '_F46_',
+                 '_F47_REFLECTION_PROBE', '_F48_', '_F49_', '_F50_DISABLE_POSTPROCESS',
+                 '_F51_', '_F52_', '_F53_COLOURISABLE', '_F54_', '_F55_MULTITEXTURE',
+                 '_F56_MATCH_GROUND', '_F57_', '_F58_USE_CENTRAL_NORMAL',
+                 '_F59_BIASED_REACTIVITY', '_F60_', '_F61_', '_F62_', '_F63_DISSOLVE',
+                 '_F64_RESERVED_FLAG_FOR_EARLY_Z_PATCHING_DO_NOT_USE']
 
 # Mesh vertex types
 VERTS = 0
@@ -39,11 +29,13 @@
 BLENDWEIGHT = 6
 
 # Mesh vertex stride sizes
-STRIDES = {VERTS: 8,
-           UVS: 8,
-           NORMS: 4,
-           TANGS: 4,
-           COLOURS: 4}
+STRIDES = {
+    VERTS: 8,
+    UVS: 8,
+    NORMS: 4,
+    TANGS: 4,
+    COLOURS: 4,
+}
 
 # Material types
 DIFFUSE = 'gDiffuseMap'
@@ -51,27 +43,33 @@
 MASKS = 'gMasksMap'
 NORMAL = 'gNormalMap'
 
-SEMANTICS = {'Vertices': VERTS,
-             'UVs': UVS,
-             'Normals': NORMS,
-             'Tangents': TANGS,
-             'Colours': COLOURS,
-             'BlendIndex': BLENDINDEX,
-             'BlendWeight': BLENDWEIGHT}
+SEMANTICS = {
+    'Vertices': VERTS,
+    'UVs': UVS,
+    'Normals': NORMS,
+    'Tangents': TANGS,
+    'Colours': COLOURS,
+    'BlendIndex': BLENDINDEX,
+    'BlendWeight': BLENDWEIGHT,
+}
 
-REV_SEMANTICS = {VERTS: 'Vertices',
-                 UVS: 'UVs',
-                 NORMS: 'Normals',
-                 TANGS: 'Tangents',
-                 COLOURS: 'Colours',
-                 BLENDINDEX: 'BlendIndex',
-                 BLENDWEIGHT: 'BlendWeight'}
+REV_SEMANTICS = {
+    VERTS: 'Vertices',
+    UVS: 'UVs',
+    NORMS: 'Normals',
+    TANGS: 'Tangents',
+    COLOURS: 'Colours',
+    BLENDINDEX: 'BlendIndex',
+    BLENDWEIGHT: 'BlendWeight',
+}
 
-SERIALIZE_FMT_MAP = {VERTS: 0,
-                     UVS: 0,
-                     NORMS: 1,
-                     TANGS: 1,
-                     COLOURS: 2}
+SERIALIZE_FMT_MAP = {
+    VERTS: 0,
+    UVS: 0,
+    NORMS: 1,
+    TANGS: 1,
+    COLOURS: 2,
+}
 
 SERIALIZE_FMT_MAP_NEW = {
     VERTS: 5131,
diff --git a/NMS/classes/Object.py b/NMS/classes/Object.py
index 3da93fb..9df5fd9 100644
--- a/NMS/classes/Object.py
+++ b/NMS/classes/Object.py
@@ -577,10 +577,8 @@ def create_attributes(self, data: dict, ignore_original: bool = False):
         # Add the LOD info
         for i, dist in enumerate(self.lod_distances):
             self.Attributes.append(
-                TkSceneNodeAttributeData(
-                    Name=f'LODDIST{i + 1}',
-                    Value=dist,
-                    fmt='{0:.6f}'))
+                TkSceneNodeAttributeData(Name=f'LODDIST{i + 1}', Value=dist)
+            )
         self.Attributes.append(
             TkSceneNodeAttributeData(Name='NUMLODS',
                                      Value=len(self.lod_distances) + 1))
diff --git a/NMS/classes/Quaternion.py b/NMS/classes/Quaternion.py
index ba0f30f..3d50212 100644
--- a/NMS/classes/Quaternion.py
+++ b/NMS/classes/Quaternion.py
@@ -8,17 +8,17 @@ def __init__(self, **kwargs):
         super(Quaternion, self).__init__()
 
         """ Contents of the struct """
-        self.data['x'] = kwargs.get('x', 0.0)
-        self.data['y'] = kwargs.get('y', 0.0)
-        self.data['z'] = kwargs.get('z', 0.0)
-        self.data['w'] = kwargs.get('w', 0.0)
+        self.data['X'] = kwargs.get('X', 0.0)
+        self.data['Y'] = kwargs.get('Y', 0.0)
+        self.data['Z'] = kwargs.get('Z', 0.0)
+        self.data['W'] = kwargs.get('W', 0.0)
         """ End of the struct contents"""
 
     def __str__(self):
-        return 'Quaternion({0}, {1}, {2}, {3})'.format(self.data['x'],
-                                                       self.data['y'],
-                                                       self.data['z'],
-                                                       self.data['w'])
+        return 'Quaternion({0}, {1}, {2}, {3})'.format(self.data['X'],
+                                                       self.data['Y'],
+                                                       self.data['Z'],
+                                                       self.data['W'])
 
     def __repr__(self):
         return str(self)
diff --git a/NMS/classes/TkAnimationData.py b/NMS/classes/TkAnimationData.py
index 311046c..abf39df 100644
--- a/NMS/classes/TkAnimationData.py
+++ b/NMS/classes/TkAnimationData.py
@@ -26,9 +26,9 @@ def __init__(self, **kwargs):
         self.data['ActionFrame'] = kwargs.get('ActionFrame', -1)
         self.data['ControlCreatureSize'] = kwargs.get('ControlCreatureSize',
                                                       'AllSizes')
-        self.data['Additive'] = kwargs.get('Additive', 'False')
-        self.data['Mirrored'] = kwargs.get('Mirrored', 'False')
-        self.data['Active'] = kwargs.get('Active', 'True')
+        self.data['Additive'] = kwargs.get('Additive', 'false')
+        self.data['Mirrored'] = kwargs.get('Mirrored', 'false')
+        self.data['Active'] = kwargs.get('Active', 'true')
         self.data['AdditiveBaseAnim'] = kwargs.get('AdditiveBaseAnim', '')
         self.data['AdditiveBaseFrame'] = kwargs.get('AdditiveBaseFrame', 0)
         self.data['GameData'] = kwargs.get('GameData', TkAnimationGameData())
diff --git a/NMS/classes/TkMaterialData.py b/NMS/classes/TkMaterialData.py
index a00caf6..5b2ec91 100644
--- a/NMS/classes/TkMaterialData.py
+++ b/NMS/classes/TkMaterialData.py
@@ -3,8 +3,11 @@
 from .Struct import Struct
 from .List import List
 from .TkMaterialFlags import TkMaterialFlags
-from .TkMaterialUniform import TkMaterialUniform
+from .TkMaterialUniform_Float import TkMaterialUniform_Float
+from .TkMaterialUniform_UInt import TkMaterialUniform_UInt
+from .TkMaterialSampler import TkMaterialSampler
 from .Vector4f import Vector4f
+from .Vector4i import Vector4i
 from .String import String
 
 
@@ -14,28 +17,42 @@ def __init__(self, **kwargs):
 
         """ Contents of the struct """
         self.data['Name'] = String(kwargs.get('Name', ""), 0x80)
+        self.data['Metamaterial'] = String(kwargs.get('Metamaterial', ""), 0x80)
         self.data['Class'] = String(kwargs.get('Class', "Opaque"), 0x20)
         self.data['TransparencyLayerID'] = kwargs.get('TransparencyLayerID', 0)
-        self.data['CastShadow'] = kwargs.get('CastShadow', "False")
-        self.data['DisableZTest'] = kwargs.get('DisableZTest', "False")
+        self.data['CastShadow'] = kwargs.get('CastShadow', "false")
+        self.data['DisableZTest'] = kwargs.get('DisableZTest', "false")
+        self.data['CreateFur'] = kwargs.get('CreateFur', "false")
+        self.data['EnableLodFade'] = kwargs.get('EnableLodFade', "false")
         self.data['Link'] = String(kwargs.get('Link', ""), 0x80)
         self.data['Shader'] = String(
             kwargs.get('Shader', "SHADERS/UBERSHADER.SHADER.BIN"), 0x80)
         self.data['Flags'] = kwargs.get('Flags', List(TkMaterialFlags()))
-        self.data['Uniforms'] = kwargs.get(
-            'Uniforms',
+        self.data['FxFlags'] = kwargs.get('FxFlags', None)
+        self.data['Uniforms_Float'] = kwargs.get(
+            'Uniforms_Float',
             List(
-                TkMaterialUniform(
+                TkMaterialUniform_Float(
                     Name="gMaterialColourVec4",
-                    Values=Vector4f(x=1.0, y=1.0, z=1.0, t=1.0)),
-                TkMaterialUniform(
+                    Values=Vector4f(X=1.000000, Y=1.000000, Z=1.000000, W=1.000000)),
+                TkMaterialUniform_Float(
                     Name="gMaterialParamsVec4",
-                    Values=Vector4f(x=0.9, y=0.5, z=0.0, t=0.0)),
-                TkMaterialUniform(
+                    Values=Vector4f(X=0.900000, Y=0.500000, Z=0.000000, W=0.000000)),
+                TkMaterialUniform_Float(
+                    Name="gMaterialParams2Vec4",
+                    Values=Vector4f(X=0.900000, Y=0.500000, Z=0.000000, W=0.000000)),
+                TkMaterialUniform_Float(
                     Name="gMaterialSFXVec4",
                     Values=Vector4f()),
-                TkMaterialUniform(
+                TkMaterialUniform_Float(
                     Name="gMaterialSFXColVec4",
                     Values=Vector4f())))
-        self.data['Samplers'] = kwargs.get('Samplers', None)
+        self.data['Uniforms_UInt'] = kwargs.get(
+            'Uniforms_UInt',
+            List(
+                TkMaterialUniform_UInt(
+                    Name="gDynamicFlags",
+                    Values=Vector4i(X=3, Y=0, Z=0, W=0))))
+        self.data['Samplers'] = kwargs.get('Samplers', TkMaterialSampler())
+        self.data['ShaderMillDataHash'] = kwargs.get('Metamaterial', 0)
         """ End of the struct contents"""
diff --git a/NMS/classes/TkMaterialSampler.py b/NMS/classes/TkMaterialSampler.py
index 33c68bf..f6efda8 100644
--- a/NMS/classes/TkMaterialSampler.py
+++ b/NMS/classes/TkMaterialSampler.py
@@ -16,7 +16,7 @@ def __init__(self, **kwargs):
         self.data['UseCompression'] = kwargs.get('UseCompression', True)
         self.data['UseMipMaps'] = kwargs.get('UseMipMaps', True)
         # True image, False for MASKS and NORMAL
-        self.data['IsSRGB'] = kwargs.get('IsSRGB', True)
+        self.data['IsSRGB'] = kwargs.get('IsSRGB', False)
         self.data['MaterialAlternativeId'] = String(kwargs.get(
             'MaterialAlternativeId', ""), 0x10)
         self.data['TextureAddressMode'] = kwargs.get(
diff --git a/NMS/classes/TkMaterialUniform.py b/NMS/classes/TkMaterialUniform_Float.py
similarity index 77%
rename from NMS/classes/TkMaterialUniform.py
rename to NMS/classes/TkMaterialUniform_Float.py
index d9a486c..2742942 100644
--- a/NMS/classes/TkMaterialUniform.py
+++ b/NMS/classes/TkMaterialUniform_Float.py
@@ -1,4 +1,4 @@
-# TkMaterialUniform struct
+# TkMaterialUniform_Float struct
 
 from .Struct import Struct
 from .String import String
@@ -6,9 +6,9 @@
 from .List import List
 
 
-class TkMaterialUniform(Struct):
+class TkMaterialUniform_Float(Struct):
     def __init__(self, **kwargs):
-        super(TkMaterialUniform, self).__init__()
+        super(TkMaterialUniform_Float, self).__init__()
 
         """ Contents of the struct """
         self.data['Name'] = String(kwargs.get('Name', None), 0x20)
diff --git a/NMS/classes/TkMaterialUniform_UInt.py b/NMS/classes/TkMaterialUniform_UInt.py
new file mode 100644
index 0000000..4297892
--- /dev/null
+++ b/NMS/classes/TkMaterialUniform_UInt.py
@@ -0,0 +1,17 @@
+# TkMaterialUniform_UInt struct
+
+from .Struct import Struct
+from .String import String
+from .Vector4i import Vector4i
+from .List import List
+
+
+class TkMaterialUniform_UInt(Struct):
+    def __init__(self, **kwargs):
+        super(TkMaterialUniform_UInt, self).__init__()
+
+        """ Contents of the struct """
+        self.data['Name'] = String(kwargs.get('Name', None), 0x20)
+        self.data['Values'] = kwargs.get('Values', Vector4i())
+        self.data['ExtendedValues'] = kwargs.get('ExtendedValues', List())
+        """ End of the struct contents"""
diff --git a/NMS/classes/Vector4f.py b/NMS/classes/Vector4f.py
index 4a141ad..0c18131 100644
--- a/NMS/classes/Vector4f.py
+++ b/NMS/classes/Vector4f.py
@@ -9,20 +9,20 @@ def __init__(self, **kwargs):
         super(Vector4f, self).__init__()
 
         """ Contents of the struct """
-        self.data['x'] = kwargs.get('x', 0.0)
-        self.data['y'] = kwargs.get('y', 0.0)
-        self.data['z'] = kwargs.get('z', 0.0)
-        self.data['t'] = kwargs.get('t', 0.0)
+        self.data['X'] = kwargs.get('X', 0.0)
+        self.data['Y'] = kwargs.get('Y', 0.0)
+        self.data['Z'] = kwargs.get('Z', 0.0)
+        self.data['W'] = kwargs.get('W', 0.0)
         """ End of the struct contents"""
 
     def __bytes__(self):
-        return pack('<ffff', self.data['x'], self.data['y'], self.data['z'], self.data['t'])
+        return pack('<ffff', self.data['X'], self.data['Y'], self.data['Z'], self.data['W'])
 
     def __str__(self):
-        return 'Vector4f({0}, {1}, {2}, {3})'.format(self.data['x'],
-                                                     self.data['y'],
-                                                     self.data['z'],
-                                                     self.data['t'])
+        return 'Vector4f({0}, {1}, {2}, {3})'.format(self.data['X'],
+                                                     self.data['Y'],
+                                                     self.data['Z'],
+                                                     self.data['W'])
 
     def __repr__(self):
         return str(self)
diff --git a/NMS/classes/Vector4i.py b/NMS/classes/Vector4i.py
new file mode 100644
index 0000000..732abb1
--- /dev/null
+++ b/NMS/classes/Vector4i.py
@@ -0,0 +1,28 @@
+# Vector4i struct
+
+from .Struct import Struct
+from struct import pack
+
+
+class Vector4i(Struct):
+    def __init__(self, **kwargs):
+        super(Vector4i, self).__init__()
+
+        """ Contents of the struct """
+        self.data['X'] = kwargs.get('X', 0)
+        self.data['Y'] = kwargs.get('Y', 0)
+        self.data['Z'] = kwargs.get('Z', 0)
+        self.data['W'] = kwargs.get('W', 0)
+        """ End of the struct contents"""
+
+    def __bytes__(self):
+        return pack('<iiii', self.data['X'], self.data['Y'], self.data['X'], self.data['W'])
+
+    def __str__(self):
+        return 'Vector4i({0}, {1}, {2}, {3})'.format(self.data['X'],
+                                                     self.data['Y'],
+                                                     self.data['Z'],
+                                                     self.data['W'])
+
+    def __repr__(self):
+        return str(self)
diff --git a/NMS/classes/__init__.py b/NMS/classes/__init__.py
index 90d4ada..28ac4ad 100644
--- a/NMS/classes/__init__.py
+++ b/NMS/classes/__init__.py
@@ -7,6 +7,7 @@
 from .Object import (Locator, Light, Mesh, Joint, Emitter, Collision, Model,  # noqa
                      Reference)
 from .Vector4f import Vector4f  # noqa
+from .Vector4i import Vector4i  # noqa
 from .Quaternion import Quaternion  # noqa
 from .NMSString0x10 import NMSString0x10  # noqa
 from .NMSString0x20 import NMSString0x20  # noqa
@@ -21,7 +22,8 @@
 from .TkSceneNodeData import TkSceneNodeData  # noqa
 from .TkMaterialData import TkMaterialData  # noqa
 from .TkMaterialFlags import TkMaterialFlags  # noqa
-from .TkMaterialUniform import TkMaterialUniform  # noqa
+from .TkMaterialUniform_Float import TkMaterialUniform_Float  # noqa
+from .TkMaterialUniform_UInt import TkMaterialUniform_UInt  # noqa
 from .TkMaterialSampler import TkMaterialSampler  # noqa
 from .TkPhysicsComponentData import TkPhysicsComponentData  # noqa
 from .TkPhysicsData import TkPhysicsData  # noqa
diff --git a/NMS/material_node.py b/NMS/material_node.py
index 3cbb93b..0bf2228 100644
--- a/NMS/material_node.py
+++ b/NMS/material_node.py
@@ -17,9 +17,9 @@ def create_material_node(mat_path: str, local_root_directory: str):
     # Create a new material
     mat = bpy.data.materials.new(name=mat_data.Name)
 
-    uniforms = {x.Name: x for x in mat_data.Uniforms}
+    uniforms = {x.Name: x for x in mat_data.Uniforms_Float}
 
-    flags = [x.MaterialFlag for x in mat_data.Flags]
+    flags = [x.MaterialFlagEnum for x in mat_data.Flags]
 
     # Since we are using cycles we want to have node-based materials
     mat.use_nodes = True
@@ -41,10 +41,7 @@ def create_material_node(mat_path: str, local_root_directory: str):
     FRAGMENT_COLOUR0 = principled_BSDF.outputs['BSDF']
 
     # Set up some constants
-    if 61 in flags:
-        kfAlphaThreshold = 0.1
-        kfAlphaThresholdMax = 0.5
-    elif 10 in flags:
+    if 10 in flags:
         kfAlphaThreshold = 0.45
         kfAlphaThresholdMax = 0.8
     else:
@@ -100,22 +97,12 @@ def create_material_node(mat_path: str, local_root_directory: str):
                 else:
                     print('Note: Please post on discord the model you are'
                           ' importing so I can fix this!!!')
-            # #ifndef _F44_IMPOSTER
-            if 43 not in flags:
-                # #ifdef _F39_METALLIC_MASK
-                if 38 in flags:
-                    links.new(principled_BSDF.inputs['Metallic'],
-                              diffuse_texture.outputs['Alpha'])
-                else:
-                    # use the default value from the file
-                    if 'gMaterialParamsVec4' in uniforms:
-                        principled_BSDF.inputs['Metallic'].default_value = uniforms['gMaterialParamsVec4'].Values[2]  # noqa
         elif tex_type == MASKS:
             # texture
             _path = realize_path(tex_path, local_root_directory)
             if _path is not None and op.exists(_path):
                 img = bpy.data.images.load(_path)
-                img.colorspace_settings.name = 'sRGB'
+                img.colorspace_settings.name = 'Linear Rec.2020'
             mask_texture = nodes.new(type='ShaderNodeTexImage')
             mask_texture.name = mask_texture.label = 'Texture Image - Mask'
             mask_texture.image = img
@@ -129,20 +116,26 @@ def create_material_node(mat_path: str, local_root_directory: str):
             if 43 not in flags:
                 # #ifndef _F44_IMPOSTER
                 if 24 in flags:
-                    # #ifdef _F25_ROUGHNESS_MASK
-                    # lfRoughness = 1 - lMasks.g
-                    # subtract the green channel from 1:
+                    # #ifdef _F25_MASKS_MAP
+                    
+                    # lfRoughness = 1 - lMasks.r
+                    # subtract the red channel from 1:
                     sub_1 = nodes.new(type="ShaderNodeMath")
                     sub_1.operation = 'SUBTRACT'
                     sub_1.location = (-200, 0)
                     sub_1.inputs[0].default_value = 1.0
                     lfRoughness = sub_1.outputs['Value']
                     # link them up
-                    links.new(sub_1.inputs[1], separate_rgb.outputs['G'])
+                    links.new(sub_1.inputs[1], separate_rgb.outputs['R'])
+                    
+                    # lfMetallic = lMasks.g;
+                    links.new(principled_BSDF.inputs['Metallic'],
+                              separate_rgb.outputs['G'])
                 else:
                     roughness_value = nodes.new(type='ShaderNodeValue')
                     roughness_value.outputs[0].default_value = 1.0
                     lfRoughness = roughness_value.outputs['Value']
+                    # Need to do the same for metallic default value?
                 # lfRoughness *= lUniforms.mpCustomPerMaterial->gMaterialParamsVec4.x;  # noqa
                 mult_param_x = nodes.new(type="ShaderNodeMath")
                 mult_param_x.operation = 'MULTIPLY'
@@ -154,23 +147,12 @@ def create_material_node(mat_path: str, local_root_directory: str):
                           lfRoughness)
             # If the roughness wasn't ever defined then the default value is 1
             # which is what blender has as the default anyway
-
-            # gMaterialParamsVec4.x
-            # #ifdef _F40_SUBSURFACE_MASK
-            if 39 in flags:
-                links.new(principled_BSDF.inputs['Subsurface Weight'],
-                          separate_rgb.outputs['R'])
-            if 43 in flags:
-                # lfMetallic = lMasks.b;
-                links.new(principled_BSDF.inputs['Metallic'],
-                          separate_rgb.outputs['B'])
-
         elif tex_type == NORMAL:
             # texture
             _path = realize_path(tex_path, local_root_directory)
             if _path is not None and op.exists(_path):
                 img = bpy.data.images.load(_path)
-                img.colorspace_settings.name = 'sRGB'
+                img.colorspace_settings.name = 'Linear Rec.2020'
             normal_texture = nodes.new(type='ShaderNodeTexImage')
             normal_texture.name = normal_texture.label = 'Texture Image - Normal'  # noqa
             normal_texture.image = img
@@ -199,25 +181,11 @@ def create_material_node(mat_path: str, local_root_directory: str):
             links.new(principled_BSDF.inputs['Normal'],
                       normal_map.outputs['Normal'])
 
-            if 42 in flags:
-                # lTexCoordsVec4.xy *= lUniforms.mpCustomPerMesh->gCustomParams01Vec4.z;  # noqa
-                normal_scale = nodes.new(type='ShaderNodeMapping')
-                normal_scale.location = (-1000, -300)
-                scale = uniforms['gCustomParams01Vec4'].Values[2]
-                normal_scale.inputs['Scale'].default_value = Vector((scale, scale, scale))  # noqa
-                tex_coord = nodes.new(type='ShaderNodeTexCoord')
-                tex_coord.location = (-1200, -300)
-                tex_coord.object = bpy.context.active_object
-                links.new(normal_scale.inputs['Vector'],
-                          tex_coord.outputs['Generated'])
-                links.new(normal_texture.inputs['Vector'],
-                          normal_scale.outputs['Vector'])
-
     # Apply some final transforms to the data before connecting it to the
     # Material output node
 
     if 20 in flags or 28 in flags:
-        # #ifdef _F21_VERTEXCOLOUR
+        # #ifdef _F21_VERTEXCUSTOM
         # lColourVec4 *= IN( mColourVec4 );
         col_attribute = nodes.new(type='ShaderNodeAttribute')
         col_attribute.attribute_name = 'Col'
diff --git a/__init__.py b/__init__.py
index 2bd7829..b143674 100644
--- a/__init__.py
+++ b/__init__.py
@@ -1,7 +1,7 @@
 bl_info = {
     "name": "No Man's Sky Development Kit",
     "author": "gregkwaste, monkeyman192",
-    "version": (0, 9, "28-pre2"),
+    "version": (0, 9, 28),
     "blender": (4, 2, 0),
     "location": "File > Export/Import",
     "description": "Create NMS scene structures and export to NMS File format",
@@ -19,7 +19,7 @@
 # become significantly nicer...
 import sys
 import os.path as op
-sys.path.append(op.dirname(__file__))
+sys.path = [op.dirname(__file__)] + sys.path
 
 # External API operators
 from .NMSDK import ImportSceneOperator, ImportMeshOperator, ExportSceneOperator
diff --git a/serialization/NMS_Structures/NMS_types.py b/serialization/NMS_Structures/NMS_types.py
index a62f96a..9e5670e 100644
--- a/serialization/NMS_Structures/NMS_types.py
+++ b/serialization/NMS_Structures/NMS_types.py
@@ -13,7 +13,23 @@
 
 
 class VariableSizeString(datatype):
+    _size = 0x10
     _alignment = 8
+    _end_padding: int = 0xAAAAAA01
+    _pad_with: bytes = b""
+
+    def __class_getitem__(cls: Type["VariableSizeString"], extra_data: Optional[tuple[int, bytes]]):
+        if extra_data is not None:
+            _end_padding, _pad_with = extra_data
+        else:
+            _end_padding = 0xAAAAAA01
+            _pad_with = b""
+        _cls: Type[NMS_list[T]] = types.new_class(
+            f"VariableSizeString[{extra_data}]", (cls,)
+        )
+        _cls._end_padding = _end_padding
+        _cls._pad_with = _pad_with
+        return _cls
 
     @classmethod
     def deserialize(cls, buf: BufferedReader) -> str:
@@ -29,9 +45,14 @@ def deserialize(cls, buf: BufferedReader) -> str:
     @classmethod
     def serialize(cls, buf: BufferedWriter, value: str):
         ptr = buf.tell()
-        buf.write(struct.pack("<QII", 0, 0, 0xAAAAAA01))
+        buf.write(struct.pack("<QII", 0, 0, cls._end_padding))
         yield
         offset = buf.tell()
+        if cls._pad_with and offset % 8 != 0:
+            # If we want padding bytes, then add them.
+            diff = 8 - (offset % 8)
+            buf.write(cls._pad_with * diff)
+            offset = buf.tell()
         value = str(value)
         size = len(value)
         if size != 0:
@@ -41,6 +62,7 @@ def serialize(cls, buf: BufferedWriter, value: str):
 
 
 class NMS_list(datatype):
+    _size = 0x10
     _alignment = 8
     _list_type: datatype
     _end_padding: int = 0xAAAAAA01
@@ -86,11 +108,20 @@ def serialize(cls, buf: BufferedWriter, value):
 
 
 class Vector4f(datatype):
+    _size = 0x10
     _alignment = 0x10
     _format = "ffff"
 
 
+class Vector4i(datatype):
+    _size = 0x10
+    _alignment = 0x10
+    _format = "IIII"
+
+
 class Quaternion_list(datatype):
+    _size = 0x10
+
     @classmethod
     def deserialize(cls, buf: BufferedReader) -> list[int]:
         start = buf.tell()
diff --git a/serialization/NMS_Structures/Structures.py b/serialization/NMS_Structures/Structures.py
index 09474ac..4fd494a 100644
--- a/serialization/NMS_Structures/Structures.py
+++ b/serialization/NMS_Structures/Structures.py
@@ -1,10 +1,14 @@
-from typing import Annotated
+from typing import Annotated, Type
+from io import BufferedWriter, BufferedReader
 from dataclasses import dataclass
+import struct
 
 from serialization.cereal_bin.structdata import datatype, Field
 import serialization.cereal_bin.basic_types as bt
 
-from serialization.NMS_Structures.NMS_types import Vector4f, NMS_list, astring, VariableSizeString, Quaternion_list
+from serialization.NMS_Structures.NMS_types import (
+    Vector4f, NMS_list, astring, VariableSizeString, Quaternion_list, Vector4i
+)
 
 
 # Materials structures
@@ -12,16 +16,28 @@
 
 @dataclass
 class TkMaterialFlags(datatype):
-    MaterialFlag: Annotated[int, Field(bt.uint32)]
+    MaterialFlagEnum: Annotated[int, Field(bt.uint32)]
 
 
 @dataclass
-class TkMaterialUniform(datatype):
+class TkMaterialFxFlags(datatype):
+    MaterialFxFlagEnum: Annotated[int, Field(bt.uint32)]
+
+
+@dataclass
+class TkMaterialUniform_Float(datatype):
     Values: Annotated[tuple[float, float, float, float], Field(Vector4f)]
     ExtendedValues: Annotated[list[tuple[float, float, float, float]], Field(NMS_list[Vector4f])]
     Name: Annotated[str, Field(VariableSizeString)]
 
 
+@dataclass
+class TkMaterialUniform_UInt(datatype):
+    Values: Annotated[tuple[int, int, int, int], Field(Vector4i)]
+    ExtendedValues: Annotated[list[tuple[int, int, int, int]], Field(NMS_list[Vector4i])]
+    Name: Annotated[str, Field(VariableSizeString)]
+
+
 @dataclass
 class TkMaterialSampler(datatype):
     MaterialAlternativeId: Annotated[str, Field(astring, 0x20)]
@@ -39,18 +55,21 @@ class TkMaterialSampler(datatype):
 @dataclass
 class TkMaterialData(datatype):
     Flags: Annotated[list[TkMaterialFlags], Field(datatype=NMS_list[TkMaterialFlags])]
+    FxFlags: Annotated[list[TkMaterialFxFlags], Field(datatype=NMS_list[TkMaterialFxFlags])]
     Link: Annotated[str, Field(VariableSizeString)]
     Metamaterial: Annotated[str, Field(VariableSizeString)]
     Name: Annotated[str, Field(VariableSizeString)]
     Samplers: Annotated[list[TkMaterialSampler], Field(datatype=NMS_list[TkMaterialSampler])]
     Shader: Annotated[str, Field(VariableSizeString)]
-    Uniforms: Annotated[list[TkMaterialUniform], Field(datatype=NMS_list[TkMaterialUniform])]
+    Uniforms_Float: Annotated[list[TkMaterialUniform_Float], Field(datatype=NMS_list[TkMaterialUniform_Float])]
+    Uniforms_UInt: Annotated[list[TkMaterialUniform_UInt], Field(datatype=NMS_list[TkMaterialUniform_UInt])]
     ShaderMillDataHash: Annotated[int, Field(bt.int64)]
     TransparencyLayerID: Annotated[int, Field(bt.int32)]
     Class: Annotated[str, Field(bt.string, 0x20)]
     CastShadow: Annotated[bool, Field(bt.boolean)]
     CreateFur: Annotated[bool, Field(bt.boolean)]
     DisableZTest: Annotated[bool, Field(bt.boolean)]
+    EnableLodFade: Annotated[bool, Field(bt.boolean)]
 
 
 # Geometry structures
@@ -113,6 +132,8 @@ class TkMeshMetaData(datatype):
     IndexDataSize: Annotated[int, Field(bt.int32)]
     VertexDataOffset: Annotated[int, Field(bt.int32)]
     VertexDataSize: Annotated[int, Field(bt.int32)]
+    VertexPositionDataOffset: Annotated[int, Field(bt.int32)]
+    VertexPositionDataSize: Annotated[int, Field(bt.int32)]
     DoubleBufferGeometry: Annotated[bool, Field(bt.boolean)]
 
 
@@ -121,7 +142,7 @@ class TkMeshMetaData(datatype):
 
 @dataclass
 class TkGeometryData(datatype):
-    SmallVertexLayout: Annotated[TkVertexLayout, Field(TkVertexLayout)]
+    PositionVertexLayout: Annotated[TkVertexLayout, Field(TkVertexLayout)]
     VertexLayout: Annotated[TkVertexLayout, Field(TkVertexLayout)]
     BoundHullVertEd: Annotated[list[int], Field(NMS_list[bt.int32, 1])]
     BoundHullVerts: Annotated[list[tuple[float, float, float, float]], Field(NMS_list[Vector4f, 1])]
@@ -149,16 +170,18 @@ class TkGeometryData(datatype):
 
 @dataclass
 class TkMeshData(datatype):
-    IdString: Annotated[str, Field(VariableSizeString)]
-    MeshDataStream: Annotated[bytearray, Field(NMS_list[bt.uint8])]
+    IdString: Annotated[str, Field(VariableSizeString[0xFEFE0101, b"\xFE"])]
+    MeshDataStream: Annotated[bytearray, Field(NMS_list[bt.uint8, 0xFEFE0101])]
+    MeshPositionDataStream: Annotated[bytearray, Field(NMS_list[bt.uint8, 0xFEFE0101])]
     Hash: Annotated[int, Field(bt.uint64)]
     IndexDataSize: Annotated[int, Field(bt.int32)]
     VertexDataSize: Annotated[int, Field(bt.int32)]
+    VertexPositionDataSize: Annotated[int, Field(bt.int32)]
 
 
 @dataclass
 class TkGeometryStreamData(datatype):
-    StreamDataArray: Annotated[list[TkMeshData], Field(NMS_list[TkMeshData])]
+    StreamDataArray: Annotated[list[TkMeshData], Field(NMS_list[TkMeshData, 0x101])]
 
 
 # Scene related
@@ -224,10 +247,75 @@ class TkAnimMetadata(datatype):
     Has30HzFrames: Annotated[bool, Field(bt.boolean)]
 
 
+class NMSTemplate(datatype):
+    _size = 0x10
+    _alignment = 8
+    _real_type: datatype
+    _end_padding: int = 0xEEEEEE01
+
+    @classmethod
+    def deserialize(cls, buf: BufferedReader) -> datatype:
+        start = buf.tell()
+        offset, namehash, _ = struct.unpack("<QII", buf.read(0x10))
+        ret = buf.tell()
+        buf.seek(start + offset)
+        if namehash in STRUCT_MAPPING:
+            data = STRUCT_MAPPING[namehash].read(buf)
+        else:
+            raise ValueError(f"Unknown struct with name hash 0x{namehash:X}")
+        buf.seek(ret)
+        return data
+
+    @classmethod
+    def serialize(cls, buf: BufferedWriter, value):
+        raise NotImplementedError()
+        # ptr = buf.tell()
+        # buf.write(struct.pack("<QII", 0, 0, cls._end_padding))
+        # yield
+        # cls._list_type._write_padding(buf)
+        # offset = buf.tell()
+        # size = len(value)
+        # if size != 0:
+        #     for v in value:
+        #         cls._list_type._write(buf, v)
+        #     buf.seek(ptr)
+        #     buf.write(struct.pack("<QI", offset - ptr, size))
+
+
+@dataclass
+class TkResourceDescriptorData(datatype):
+    Id: Annotated[str, Field(astring, 0x20)]
+    Children: Annotated[list[NMSTemplate], Field(NMS_list[NMSTemplate])]
+    ReferencePaths: Annotated[list[str], Field(NMS_list[VariableSizeString])]
+    Chance: Annotated[float, Field(bt.single)]
+    Name: Annotated[str, Field(bt.string, length=0x80)]
+
+
+@dataclass
+class TkResourceDescriptorList(datatype):
+    Descriptors: Annotated[list[TkResourceDescriptorData], Field(NMS_list[TkResourceDescriptorData])]
+    TypeId: Annotated[str, Field(bt.string, length=0x10)]
+
+
+@dataclass
+class TkModelDescriptorList(datatype):
+    List: Annotated[list[TkResourceDescriptorList], Field(NMS_list[TkResourceDescriptorList])]
+
+
 NAMEHASH_MAPPING = {
     "TkAnimMetadata": 0x8E7F1986,
     "TkSceneNodeData": 0x3DB87E47,
     "TkGeometryData": 0x819C3220,
     "TkGeometryStreamData": 0x40025754,
     "TkMaterialData": 0x4737D48A,
+    "TkModelDescriptorList": 0x4026294F,
+}
+
+STRUCT_MAPPING: dict[int, Type[datatype]] = {
+    0x8E7F1986: TkAnimMetadata,
+    0x3DB87E47: TkSceneNodeData,
+    0x819C3220: TkGeometryData,
+    0x40025754: TkGeometryStreamData,
+    0x4737D48A: TkMaterialData,
+    0x4026294F: TkModelDescriptorList,
 }
diff --git a/serialization/cereal_bin/structdata.py b/serialization/cereal_bin/structdata.py
index 748fec5..4173dcf 100644
--- a/serialization/cereal_bin/structdata.py
+++ b/serialization/cereal_bin/structdata.py
@@ -1,10 +1,14 @@
 from io import BytesIO, BufferedWriter, BufferedReader
 import struct
 import inspect
-from typing import Optional, Any, TypeVar, get_type_hints, Annotated
+from typing import Optional, Any, TypeVar, Type
 from dataclasses import dataclass
 
 
+T = TypeVar("T", bound="datatype")
+N = TypeVar("N", bound=int)
+
+
 class AlignedData(type):
     @property
     def alignment(cls):
@@ -35,6 +39,27 @@ def alignment(self):
         else:
             return type(self).alignment
 
+    @classmethod
+    def total_size(cls: "datatype"):
+        if hasattr(cls, "_size"):
+            return cls._size
+        _max_alignment = 0
+        _current_pos = 0
+        for name, type_ in cls.__annotations__.items():
+            if name.startswith("_"):
+                continue
+            if hasattr(type_, "_alignment"):
+                _alignment = type_._alignment
+                _max_alignment = max(_max_alignment, _alignment)
+                if _current_pos % _alignment != 0:
+                    _current_pos += (_alignment - (_current_pos % _alignment))
+
+            if hasattr(type_, "_size"):
+                _current_pos += type_._size
+            else:
+                if issubclass(type_, datatype):
+                    _current_pos += type_.total_size()
+
     @property
     def size(self):
         if hasattr(self, "_size"):
@@ -155,7 +180,7 @@ def _read(cls, buf: BufferedReader, meta: Optional["Field"] = None):
             return cls.read(buf)
 
     @classmethod
-    def read(cls, buf: BufferedReader):
+    def read(cls: Type[T], buf: BufferedReader) -> T:
         cls_ = cls.__new__(cls)
         for name, pytype in cls_.__annotations__.items():
             if name.startswith("_"):
@@ -175,7 +200,7 @@ def read(cls, buf: BufferedReader):
                 try:
                     setattr(cls_, name, type_._read(buf, meta))
                 except:
-                    print(f"Error reading {name} ({pytype}) at offset 0x{buf.tell():X}")
+                    print(f"Error reading {cls.__name__}.{name} ({pytype}) at offset 0x{buf.tell():X}")
                     raise
         return cls_
 
@@ -186,7 +211,3 @@ class Field:
     length: Optional[int] = None
     encoding: Optional[str] = None
     deferred_loading: bool = False
-
-
-T = TypeVar("T", bound=datatype)
-N = TypeVar("N", bound=int)
diff --git a/serialization/serializers.py b/serialization/serializers.py
index c5e34e6..2efab97 100644
--- a/serialization/serializers.py
+++ b/serialization/serializers.py
@@ -9,7 +9,7 @@ def serialize_geometry_stream(data):
     pass
 
 
-def serialize_vertex_stream(requires: List[str], **kwargs):
+def serialize_vertex_stream(requires: List[str], count: int, **kwargs):
     """
     Return a serialized version of the vertex data
 
@@ -21,7 +21,6 @@ def serialize_vertex_stream(requires: List[str], **kwargs):
         include something.
     """
     data = bytearray()
-    count = len(kwargs.get('Vertices', list()))
     if count != 0:
         for i in range(count):
             for stream_type in requires:
diff --git a/utils/utils.py b/utils/utils.py
index 092de51..219d7b5 100644
--- a/utils/utils.py
+++ b/utils/utils.py
@@ -1,7 +1,7 @@
 import xml.etree.ElementTree as ET
 
 
-def mxml_to_dict(fpath: str) -> dict:
+def mxml_to_dict(fpath) -> dict:
     tree = ET.parse(fpath)
     root = tree.getroot()
     return element_to_dict(root)