path: root/game/src/Game/Model/XACLoader.gd

class_name XACLoader

static var unit_shader : ShaderMaterial = preload("res://src/Game/Model/unit_colours_mat.tres")
const MAX_UNIT_TEXTURES : int = 32 # max number of textures supported by the shader
const EXTRA_CULL_MARGIN : int = 2 # extra margin to stop sub-meshes from being culled near the edges of screens
static var added_unit_textures_spec : PackedStringArray
static var added_unit_textures_diffuse : PackedStringArray

static var flag_shader : ShaderMaterial = preload("res://src/Game/Model/flag_mat.tres")

static var scrolling_shader : ShaderMaterial = preload("res://src/Game/Model/scrolling_mat.tres")
const MAX_SCROLLING_TEXTURES : int = 32 # max number of textures supported by the shader
static var added_scrolling_textures_diffuse : PackedStringArray
const SCROLLING_MATERIAL_FACTORS : Dictionary = {
   "TexAnim" : 2.5, # Tank tracks
   "Smoke" : 0.3 # Buildings, factories, steam ships, sieges
}

static func setup_flag_shader() -> void:
   flag_shader.set_shader_parameter(&"flag_dims", GameSingleton.get_flag_dims())
   flag_shader.set_shader_parameter(&"texture_flag_sheet_diffuse", GameSingleton.get_flag_sheet_texture())

# Keys: source_file (String)
# Values: loaded model (UnitModel or Node3D) or LOAD_FAILED_MARKER (StringName)
static var xac_cache : Dictionary

const LOAD_FAILED_MARKER : StringName = &"XAC LOAD FAILED"

static func get_xac_model(source_file : String, is_unit : bool) -> Node3D:
   var cached : Variant = xac_cache.get(source_file)
   if not cached:
      cached = _load_xac_model(source_file, is_unit)
      if cached:
         xac_cache[source_file] = cached
      else:
         xac_cache[source_file] = LOAD_FAILED_MARKER
         push_error("Failed to get XAC model \"", source_file, "\" (current load failed)")
         return null

   if not cached is Node3D:
      push_error("Failed to get XAC model \"", source_file, "\" (previous load failed)")
      return null

   var node : Node3D = cached.duplicate()
   if node is UnitModel:
      node.unit_init()
   return node

static func _load_xac_model(source_file : String, is_unit : bool) -> Node3D:
   var source_path : String = GameSingleton.lookup_file_path(source_file)
   var file : FileAccess = FileAccess.open(source_path, FileAccess.READ)
   if file == null:
      push_error("Failed to load XAC ", source_file, " from looked up path ", source_path)
      return null

   var metaDataChunk : MetadataChunk
   var nodeHierarchyChunk : NodeHierarchyChunk
   var materialTotalsChunk : MaterialTotalsChunk
   var materialDefinitionChunks : Array[MaterialDefinitionChunk] = []
   var mesh_chunks : Array[MeshChunk] = []
   var skinningChunks : Array[SkinningChunk] = []
   var chunkType6s : Array[ChunkType6] = []
   var nodeChunks : Array[NodeChunk] = []
   var chunkType4s : Array[ChunkTypeUnknown] = []
   var chunkUnknowns : Array[ChunkTypeUnknown] = []

   readHeader(file)

   while file.get_position() < file.get_length():
      var type : int = FileAccessUtils.read_int32(file)
      var length : int = FileAccessUtils.read_int32(file)
      var version : int = FileAccessUtils.read_int32(file)
      match type:
         0x7:
            metaDataChunk = readMetaDataChunk(file)
         0xB:
            nodeHierarchyChunk = readNodeHierarchyChunk(file)
         0xD:
            materialTotalsChunk = readMaterialTotalsChunk(file)
         0x3:
            # Ver=1 Appears on old version of format
            var chunk : MaterialDefinitionChunk = readMaterialDefinitionChunk(file, version==1)
            if chunk.has_specular():
               is_unit = true
            materialDefinitionChunks.push_back(chunk)
         0x1:
            mesh_chunks.push_back(readMeshChunk(file))
         0x2:
            skinningChunks.push_back(readSkinningChunk(file,mesh_chunks, version==2))
         0x6:
            chunkType6s.push_back(readChunkType6(file))
         0x0: # Appears on old version of format
            nodeChunks.push_back(readNodeChunk(file))
         0xA: # Appears on old version of format
            chunkUnknowns.push_back(readChunkTypeUnknown(file, length))
         0x4: # Appears on old version of format
            chunkType4s.push_back(readChunkTypeUnknown(file, length))
         0x8:
            push_warning("XAC model ", source_file, " contains junk data chunk 0x8 (skipping)")
            break
         _:
            push_error(">> INVALID XAC CHUNK TYPE %s in model %s" % [type, source_file])
            break

   #BUILD THE GODOT MATERIALS
   var materials : Array[MaterialDefinition] = make_materials(materialDefinitionChunks)

   #BUILD THE MESH
   var node : Node3D = null

   if is_unit:
      node = UnitModel.new()
   else:
      node = Node3D.new()

   node.name = metaDataChunk.origFileName.replace("\\", "/").split("/", false)[-1].get_slice(".", 0)

   var skeleton : Skeleton3D = null

   # build the skeleton hierarchy
   if nodeHierarchyChunk:
      skeleton = build_armature(nodeHierarchyChunk)
   elif not nodeChunks.is_empty():
      skeleton = build_armature_chunk0(nodeChunks)

   if skeleton:
      node.add_child(skeleton)
   else:
      push_warning("MODEL HAS NO SKELETON: ", source_file)

   var st : SurfaceTool = SurfaceTool.new()

   for chunk : MeshChunk in mesh_chunks:
      var mesh_chunk_name : String
      if nodeHierarchyChunk:
         mesh_chunk_name = nodeHierarchyChunk.nodes[chunk.nodeId].name
      elif not nodeChunks.is_empty():
         mesh_chunk_name = nodeChunks[chunk.nodeId].name

      const INVALID_MESHES : PackedStringArray = ["polySurface95"]
      if mesh_chunk_name in INVALID_MESHES:
         push_warning("Skipping unused mesh \"", mesh_chunk_name, "\" in model \"", node.name, "\"")
         continue

      # polySurface97 corresponds to the "arab_infantry_helmet", and needs to be removed often
      # but only in cases where it isn't an attachment
      const INVALID_IF_NOT_ONLY_MESH : PackedStringArray = ["polySurface97"]
      if mesh_chunks.size() != 1 and mesh_chunk_name in INVALID_IF_NOT_ONLY_MESH:
         push_warning("Skipping unused mesh \"", mesh_chunk_name, "\" in model \"", node.name, "\" because it was not the only mesh chunk in its file")
         break

      var mesh : ArrayMesh = null
      var verts : PackedVector3Array
      var normals : PackedVector3Array
      var tangents : Array[Vector4]
      var uvs : Array[PackedVector2Array] = []
      var influenceRangeInd : PackedInt64Array

      # vert attributes could be in any order, so search for them
      for vertAttrib : VerticesAttribute in chunk.VerticesAttributes:
         match vertAttrib.type:
            0: # position
               verts = vertAttrib.data
            1: # normals vec3
               normals = vertAttrib.data
            2: # tangents vec4
               tangents = vertAttrib.data
            3: # uv coords vec2
               uvs.push_back(vertAttrib.data) #can have multiple sets of uv data
            5: # influence range, uint32
               influenceRangeInd = vertAttrib.data
            _: # type 4 32bit colours and type 6 128bit colours aren't used
               pass

      #FIXME: find a better solution if possible
      #pCube1 hardcoding is to fix the cruiser which doesn't properly mark its collision mesh
      if chunk.bIsCollisionMesh or mesh_chunk_name == "pCube1":
         var ar3d : Area3D = Area3D.new()
         node.add_child(ar3d)
         ar3d.owner = node
         for submesh : SubMesh in chunk.SubMeshes:
            var shape : ConvexPolygonShape3D = ConvexPolygonShape3D.new()
            shape.points = verts

            var col : CollisionShape3D = CollisionShape3D.new()
            col.shape = shape

            ar3d.add_child(col)
            col.owner = node
         continue

      #TODO will this produce correct results?
      var applyVertexWeights : bool = true
      var skinning_chunk_ind : int = 0
      for skin : SkinningChunk in skinningChunks:
         if skin.nodeId == chunk.nodeId:
            break
         skinning_chunk_ind += 1
      if skinning_chunk_ind >= len(skinningChunks):
         skinning_chunk_ind =  1
         applyVertexWeights = false

      var meshInstance : MeshInstance3D = MeshInstance3D.new()
      node.add_child(meshInstance)
      meshInstance.owner = node
      
      #stop the culling of units near the tops of screens
      meshInstance.extra_cull_margin = EXTRA_CULL_MARGIN

      if mesh_chunk_name:
         meshInstance.name = mesh_chunk_name

      if skeleton:
         meshInstance.skeleton = meshInstance.get_path_to(skeleton)

      if not verts.is_empty():
         var vert_total : int = 0
         var surfaceIndex : int = 0

         for submesh : SubMesh in chunk.SubMeshes:
            st.begin(Mesh.PRIMITIVE_TRIANGLES)

            for i : int in submesh.relativeIndices.size():
               var rel_index : int = vert_total + submesh.relativeIndices[i]

               if not normals.is_empty():
                  st.set_normal(normals[rel_index])

               if not tangents.is_empty():
                  st.set_tangent(Plane(
                     -tangents[rel_index].x,
                     tangents[rel_index].y,
                     tangents[rel_index].z,
                     tangents[rel_index].w
                  ))

               if not uvs.is_empty():
                  st.set_uv(uvs[0][rel_index])

               if not influenceRangeInd.is_empty() and not skinningChunks.is_empty() and applyVertexWeights:
                  #TODO: Which skinning Chunk?
                  # likely look at the skinning chunk's nodeId, see if it matches our mesh's id
                  var vert_inf_range_ind : int = influenceRangeInd[rel_index]
                  var skin_chunk : SkinningChunk = skinningChunks[skinning_chunk_ind]
                  var influenceRange : InfluenceRange = skin_chunk.influenceRange[vert_inf_range_ind]
                  var boneWeights : Array[InfluenceData] = skinningChunks[skinning_chunk_ind].influenceData.slice(
                     influenceRange.firstInfluenceIndex,
                     influenceRange.firstInfluenceIndex + influenceRange.numInfluences
                  )
                  if len(boneWeights) > 4:
                     push_error("num BONE WEIGHTS WAS > 4, GODOT DOESNT LIKE THIS")
                     # TODO: Less hacky fix?
                     boneWeights = boneWeights.slice(0,4)

                  var godotBoneIds : PackedInt32Array = PackedInt32Array()
                  var godotBoneWeights : PackedFloat32Array = PackedFloat32Array()
                  godotBoneIds.resize(4)
                  godotBoneIds.fill(0)
                  godotBoneWeights.resize(4)
                  godotBoneWeights.fill(0)

                  var index : int = 0
                  for bone : InfluenceData in boneWeights:
                     godotBoneIds.set(index, bone.boneId)
                     godotBoneWeights.set(index, bone.fWeight)
                     index += 1

                  if skeleton:
                     st.set_bones(godotBoneIds)
                     st.set_weights(godotBoneWeights)

               st.add_vertex(verts[rel_index])

            vert_total += submesh.numVertices

            mesh = st.commit(mesh) # add a new surface to the mesh
            meshInstance.mesh = mesh

            st.clear()

            mesh.surface_set_material(surfaceIndex, materials[submesh.materialId].mat)
            surfaceIndex += 1

            if materials[submesh.materialId].spec_index != -1:
               meshInstance.set_instance_shader_parameter(&"tex_index_specular", materials[submesh.materialId].spec_index)

            if materials[submesh.materialId].diffuse_index != -1:
               meshInstance.set_instance_shader_parameter(&"tex_index_diffuse", materials[submesh.materialId].diffuse_index)

            if materials[submesh.materialId].scroll_index != -1:
               meshInstance.set_instance_shader_parameter(&"scroll_tex_index_diffuse", materials[submesh.materialId].scroll_index)

   return node

# Information needed to set up a material
# Leave the indices -1 if not using the unit shader
class MaterialDefinition:
   var spec_index : int = -1
   var diffuse_index : int = -1
   var scroll_index : int = -1
   var mat : Material

   func _init(mat : Material, diffuse_ind : int = -1, spec_ind : int = -1, scroll_ind : int = -1) -> void:
      self.mat = mat
      self.diffuse_index = diffuse_ind
      self.spec_index = spec_ind
      self.scroll_index = scroll_ind

static func make_materials(materialDefinitionChunks : Array[MaterialDefinitionChunk]) -> Array[MaterialDefinition]:
   const TEXTURES_PATH : String = "gfx/anims/%s.dds"

   var materials : Array[MaterialDefinition] = []

   for matdef : MaterialDefinitionChunk in materialDefinitionChunks:
      var diffuse_name : String
      var specular_name : String
      var normal_name : String

      # Find important textures
      for layer : Layer in matdef.Layers:
         if layer.texture in ["nospec", "unionjacksquare", "test256texture"]:
            continue

         match layer.mapType:
            2: # diffuse
               if not diffuse_name:
                  diffuse_name = layer.texture
               else:
                  push_error("Multiple diffuse layers in material: ", diffuse_name, " and ", layer.texture)

            3: # specular
               if not specular_name:
                  specular_name = layer.texture
               else:
                  push_error("Multiple specular layers in material: ", specular_name, " and ", layer.texture)

            4: # currently unused
               pass

            5: # normal
               if not normal_name:
                  normal_name = layer.texture
               else:
                  push_error("Multiple normal layers in material: ", normal_name, " and ", layer.texture)

            _:
               push_error("Unknown layer type: ", layer.mapType)
               pass

      # Unit colour mask
      if diffuse_name and specular_name:
         if normal_name:
            push_error("Normal texture present in unit colours material: ", normal_name)

         var textures_index_spec : int = added_unit_textures_spec.find(specular_name)
         if textures_index_spec < 0:
            var unit_colours_mask_texture : ImageTexture = AssetManager.get_texture(TEXTURES_PATH % specular_name)
            if unit_colours_mask_texture:
               added_unit_textures_spec.push_back(specular_name)

               # Should we still attempt to add the texture to the shader?
               if len(added_unit_textures_spec) >= MAX_UNIT_TEXTURES:
                  push_error("Colour masks have exceeded max number of textures supported by unit shader!")

               const param_texture_nation_colors_mask : StringName = &"texture_nation_colors_mask"

               var colour_masks : Array = unit_shader.get_shader_parameter(param_texture_nation_colors_mask)
               colour_masks.push_back(unit_colours_mask_texture)
               textures_index_spec = len(colour_masks) - 1
               unit_shader.set_shader_parameter(param_texture_nation_colors_mask, colour_masks)
            else:
               push_error("Failed to load specular texture: ", specular_name)

         var textures_index_diffuse : int = added_unit_textures_diffuse.find(diffuse_name)
         if textures_index_diffuse < 0:
            var diffuse_texture : ImageTexture = AssetManager.get_texture(TEXTURES_PATH % diffuse_name)
            if diffuse_texture:
               added_unit_textures_diffuse.push_back(diffuse_name)

               # Should we still attempt to add the texture to the shader?
               if len(added_unit_textures_diffuse) >= MAX_UNIT_TEXTURES:
                  push_error("Diffuse textures have exceeded max number supported by unit shader!")

               const param_texture_diffuse : StringName = &"texture_diffuse"

               var diffuse_textures : Array = unit_shader.get_shader_parameter(param_texture_diffuse)
               diffuse_textures.push_back(diffuse_texture)
               textures_index_diffuse = len(diffuse_textures) - 1
               unit_shader.set_shader_parameter(param_texture_diffuse, diffuse_textures)
            else:
               push_error("Failed to load diffuse texture: ", diffuse_name)

         materials.push_back(MaterialDefinition.new(unit_shader, textures_index_diffuse, textures_index_spec))

      # Flag (diffuse is unionjacksquare which is ignored)
      elif normal_name and not diffuse_name:
         if specular_name:
            push_error("Specular texture present in flag material: ", specular_name)

         var flag_normal_texture : ImageTexture = AssetManager.get_texture(TEXTURES_PATH % normal_name)
         if flag_normal_texture:
            flag_shader.set_shader_parameter(&"texture_normal", flag_normal_texture)
         else:
            push_error("Failed to load normal texture: ", normal_name)

         materials.push_back(MaterialDefinition.new(flag_shader))

      # Scrolling texture
      elif diffuse_name and matdef.name in SCROLLING_MATERIAL_FACTORS:
         if specular_name:
            push_error("Specular texture present in scrolling material: ", specular_name)
         if normal_name:
            push_error("Normal texture present in scrolling material: ", normal_name)

         var scroll_textures_index_diffuse : int = added_scrolling_textures_diffuse.find(diffuse_name)
         if scroll_textures_index_diffuse < 0:
            var diffuse_texture : ImageTexture = AssetManager.get_texture(TEXTURES_PATH % diffuse_name)
            if diffuse_texture:
               added_scrolling_textures_diffuse.push_back(diffuse_name)

               # Should we still attempt to add the texture to the shader?
               if len(added_scrolling_textures_diffuse) >= MAX_SCROLLING_TEXTURES:
                  push_error("Diffuse textures have exceeded max number supported by scrolling shader!")

               const param_scroll_texture_diffuse : StringName = &"scroll_texture_diffuse"

               var scroll_diffuse_textures : Array = scrolling_shader.get_shader_parameter(param_scroll_texture_diffuse)
               scroll_diffuse_textures.push_back(diffuse_texture)
               scroll_textures_index_diffuse = len(scroll_diffuse_textures) - 1
               scrolling_shader.set_shader_parameter(param_scroll_texture_diffuse, scroll_diffuse_textures)

               const param_scroll_factor : StringName = &"scroll_factor"

               var scroll_factors : Array = scrolling_shader.get_shader_parameter(param_scroll_factor)
               scroll_factors.push_back(SCROLLING_MATERIAL_FACTORS[matdef.name])
               scrolling_shader.set_shader_parameter(param_scroll_factor, scroll_factors)
            else:
               push_error("Failed to load diffuse texture: ", diffuse_name)

         materials.push_back(MaterialDefinition.new(scrolling_shader, -1, -1, scroll_textures_index_diffuse))

      # Standard material
      else:
         if specular_name:
            push_error("Specular texture present in standard material: ", specular_name)

         var mat : StandardMaterial3D = StandardMaterial3D.new()
         mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA_DEPTH_PRE_PASS

         if diffuse_name:
            var diffuse_texture : ImageTexture = AssetManager.get_texture(TEXTURES_PATH % diffuse_name)
            if diffuse_texture:
               mat.set_texture(BaseMaterial3D.TEXTURE_ALBEDO, diffuse_texture)
            else:
               push_error("Failed to load diffuse texture: ", diffuse_name)

         if normal_name:
            var normal_texture : ImageTexture = AssetManager.get_texture(TEXTURES_PATH % normal_name)
            if normal_texture:
               mat.normal_enabled = true
               mat.set_texture(BaseMaterial3D.TEXTURE_NORMAL, normal_texture)
            else:
               push_error("Failed to load normal texture: ", normal_name)

         #TODO: Verify that this is correct thing to do to make sure
         #that places where models are double sided are correct
         mat.cull_mode = BaseMaterial3D.CULL_DISABLED

         materials.push_back(MaterialDefinition.new(mat))

   return materials

static func build_armature(hierarchy_chunk : NodeHierarchyChunk) -> Skeleton3D:
   var skeleton : Skeleton3D = Skeleton3D.new()
   skeleton.name = "skeleton"
   var cur_id : int = 0
   for node : NodeData in hierarchy_chunk.nodes:
      # godot doesn't like the ':' in bone names unlike paradox
      skeleton.add_bone(FileAccessUtils.replace_chars(node.name))
      skeleton.set_bone_parent(cur_id, node.parentNodeId)

      #For now assume rest and current position are the same
      skeleton.set_bone_rest(cur_id, Transform3D(Basis(node.rotation).scaled(node.scale), node.position))

      skeleton.set_bone_pose_position(cur_id, node.position)
      skeleton.set_bone_pose_rotation(cur_id, node.rotation)
      skeleton.set_bone_pose_scale(cur_id, node.scale)

      cur_id += 1
   # conveniently both godot and xac use a parent node id of -1 to represent no parent
   # TODO: What is the point of xac having both a transform and separate vec3s for rotation, scale, pos, etc.?
   # for now, will assume the separate components are the truth
   # it might be that one is a current position and the other is a rest position?
   return skeleton

static func build_armature_chunk0(nodeChunks : Array[NodeChunk]) -> Skeleton3D:
   var skeleton : Skeleton3D = Skeleton3D.new()
   skeleton.name = "skeleton"
   var cur_id : int = 0
   for node : NodeChunk in nodeChunks:
      # godot doesn't like the ':' in bone names unlike paradox
      skeleton.add_bone(FileAccessUtils.replace_chars(node.name))
      skeleton.set_bone_parent(cur_id, node.parentBone)

      # For now assume rest and current position are the same
      skeleton.set_bone_rest(cur_id, Transform3D(Basis(node.rotation).scaled(node.scale), node.position))

      skeleton.set_bone_pose_position(cur_id, node.position)
      skeleton.set_bone_pose_rotation(cur_id, node.rotation)
      skeleton.set_bone_pose_scale(cur_id, node.scale)

      cur_id += 1
   return skeleton

static func readHeader(file : FileAccess) -> void:
   var magic_bytes : PackedByteArray = [file.get_8(), file.get_8(), file.get_8(), file.get_8()]
   var magic : String = magic_bytes.get_string_from_ascii()
   var version : String = "%d.%d" % [file.get_8(), file.get_8()]
   var bBigEndian : bool = file.get_8()
   var multiplyOrder : int = file.get_8()
   #print(magic, ", version: ", version, ", bigEndian: ", bBigEndian, " multiplyOrder: ", multiplyOrder)

static func readMetaDataChunk(file : FileAccess) -> MetadataChunk:
   return MetadataChunk.new(
      file.get_32(), FileAccessUtils.read_int32(file), file.get_8(), file.get_8(),
      Vector2i(file.get_8(), file.get_8()), file.get_float(),
      FileAccessUtils.read_xac_str(file), FileAccessUtils.read_xac_str(file),
      FileAccessUtils.read_xac_str(file), FileAccessUtils.read_xac_str(file)
   )

class MetadataChunk:
   var repositionMask : int # uint32
   var repositioningNode : int # int32
   var exporterMajorVersion : int # byte
   var exporterMinorVersion : int # byte
   var unused : Vector2i # 2x byte
   var retargetRootOffset : float
   var sourceApp : String
   var origFileName : String
   var exportDate : String
   var actorName : String

   func _init(
      repMask : int,
      repNode : int,
      exMajV : int,
      exMinV : int,
      un : Vector2i,
      retRootOff : float,
      sourceApp : String,
      origFile : String,
      date : String,
      actorName : String
   ) -> void:
      self.repositionMask = repMask
      self.repositioningNode = repNode
      self.exporterMajorVersion = exMajV
      self.exporterMinorVersion = exMinV
      self.unused = un
      self.retargetRootOffset = retRootOff
      self.sourceApp = sourceApp
      self.origFileName = origFile
      self.exportDate = date
      self.actorName = actorName

   func debugPrint() -> void:
      print("Ver: %d.%d, exported: %s, fileName: %s, sourceApp: %s" %
         [exporterMajorVersion, exporterMinorVersion, exportDate, origFileName, sourceApp])
      print("Actor: %s, retargetRootOffset: %d, repositionMask: %d, repositionNode: %d" %
         [actorName, retargetRootOffset, repositionMask, repositioningNode])

# HIERARCHY

static func readNodeData(file : FileAccess) -> NodeData:
   return NodeData.new(
      FileAccessUtils.read_quat(file), FileAccessUtils.read_quat(file),
      FileAccessUtils.read_pos(file), FileAccessUtils.read_vec3(file),
      FileAccessUtils.read_vec3(file), # 3x unused floats
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file),
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file),
      FileAccessUtils.read_mat4x4(file), file.get_float(), FileAccessUtils.read_xac_str(file)
   )

class NodeData:
   var rotation : Quaternion
   var scaleRotation : Quaternion
   var position : Vector3
   var scale : Vector3
   var unused : Vector3 # 3x unused floats
   var unknown : int # int32
   var unknown2 : int # int32
   var parentNodeId : int # int32
   var numChildNodes : int # int32
   var bIncludeInBoundsCalc : bool # int32
   var transform : FileAccessUtils.xac_mat4x4
   var fImportanceFactor : float
   var name : String

   func _init(
      rot : Quaternion,
      scaleRot : Quaternion,
      pos : Vector3,
      scale : Vector3,
      unused : Vector3,
      unknown : int,
      unknown2 : int,
      parentNodeId : int,
      numChildNodes : int,
      incInBoundsCalc : bool,
      transform : FileAccessUtils.xac_mat4x4,
      fImportanceFactor : float,
      name : String
   ) -> void:
      self.rotation = rot
      self.scaleRotation = scaleRot
      self.position = pos
      self.scale = scale
      self.unused = unused
      self.unknown = unknown2
      self.unknown2 = unknown2
      self.parentNodeId = parentNodeId
      self.numChildNodes = numChildNodes
      self.bIncludeInBoundsCalc = incInBoundsCalc
      self.transform = transform
      self.fImportanceFactor = fImportanceFactor
      self.name = name

   func debugPrint() -> void:
      print("\tparentNodeId: %d,\t numChildNodes: %d,\t Node Name: %s" % [parentNodeId, numChildNodes, name])
      print("\tunused %s,%s,%s, -1: %s, -1: %s" % [unused[0], unused[1], unused[2], unknown, unknown2])

static func readNodeHierarchyChunk(file : FileAccess) -> NodeHierarchyChunk:
   var numNodes : int = FileAccessUtils.read_int32(file)
   var numRootNodes : int = FileAccessUtils.read_int32(file)
   var nodes : Array[NodeData] = []
   for i : int in numNodes:
      nodes.push_back(readNodeData(file))
   return NodeHierarchyChunk.new(numNodes, numRootNodes, nodes)

class NodeHierarchyChunk:
   var numNodes : int # int32
   var numRootNodes : int # int32
   var nodes : Array[NodeData]

   func _init(numNodes : int, numRootNodes : int, nodes : Array[NodeData]) -> void:
      self.numNodes = numNodes
      self.numRootNodes = numRootNodes
      self.nodes = nodes

   func debugPrint() -> void:
      print("numNodes: %d, numRootNodes: %d" % [numNodes, numRootNodes])
      for node : NodeData in nodes:
         node.debugPrint()

# MATERIAL TOTALS

static func readMaterialTotalsChunk(file : FileAccess) -> MaterialTotalsChunk:
   return MaterialTotalsChunk.new(FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file))

class MaterialTotalsChunk:
   var numTotalMaterials : int # int32
   var numStandMaterials : int # int32
   var numFxMaterials : int # int32

   func _init(numTotalMaterials : int, numStandMaterials : int, numFxMaterials : int) -> void:
      self.numTotalMaterials = numTotalMaterials
      self.numStandMaterials = numStandMaterials
      self.numFxMaterials = numFxMaterials

   func debugPrint() -> void:
      print("totalMaterials: %d, standardMaterials: %d, fxMaterials: %d" %
         [numTotalMaterials, numStandMaterials, numFxMaterials])

# MATERIAL DEFINITION

static func readLayer(file : FileAccess, isV1 : bool) -> Layer:
   var unknown : Vector3i
   if isV1:
      unknown = Vector3i(
         FileAccessUtils.read_int32(file),
         FileAccessUtils.read_int32(file),
         FileAccessUtils.read_int32(file)
      )
   var layer : Layer = Layer.new(
      file.get_float(), file.get_float(), file.get_float(), file.get_float(),
      file.get_float(), file.get_float(), FileAccessUtils.read_int16(file),
      file.get_8(), file.get_8(), FileAccessUtils.read_xac_str(file), unknown
   )
   return layer

class Layer:
   var amount : float
   var uOffset : float
   var vOffset : float
   var uTiling : float
   var vTiling : float
   var rotInRad : float
   var matId : int # int16
   var mapType : int # byte
   var unused : int # byte
   var texture : String
   var unknown : Vector3i # Unknown 3 integers present in v1 of the chunk

   func _init(
      amount : float,
      uOffset : float,
      vOffset : float,
      uTiling : float,
      vTiling : float,
      rotInRad : float,
      matId : int,
      mapType : int,
      unused : int,
      texture : String,
      unknown : Vector3i
   ) -> void:
      self.amount = amount
      self.uOffset = uOffset
      self.vOffset = vOffset
      self.uTiling = uTiling
      self.vTiling = vTiling
      self.rotInRad = rotInRad
      self.matId = matId
      self.mapType = mapType
      self.unused = unused
      self.texture = texture
      self.unknown = unknown

   func debugPrint() -> void:
      print("\tLayer MatId:%d,\t UVOffset:%d,%d,\t UVTiling %d,%d mapType: %d,\t Texture Name: %s" %
         [matId, uOffset, vOffset, uTiling, vTiling, mapType, texture])
      print("\t  amount:%s,\t rot:%s,\t unused:%d" % [amount, rotInRad, unused])

   func is_specular() -> bool:
      return mapType == 3

# TODO: Might want to change this from vec4d to colours where appropriate
static func readMaterialDefinitionChunk(file : FileAccess, isV1 : bool) -> MaterialDefinitionChunk:
   var chunk : MaterialDefinitionChunk = MaterialDefinitionChunk.new(
      FileAccessUtils.read_vec4(file), FileAccessUtils.read_vec4(file),
      FileAccessUtils.read_vec4(file), FileAccessUtils.read_vec4(file),
      file.get_float(), file.get_float(), file.get_float(), file.get_float(),
      file.get_8(), file.get_8(), file.get_8(), file.get_8(),
      FileAccessUtils.read_xac_str(file)
   )
   var layers : Array[Layer] = []
   for i : int in chunk.numLayers:
      layers.push_back(readLayer(file, isV1))
   chunk.setLayers(layers)
   return chunk

class MaterialDefinitionChunk:
   var ambientColor : Vector4
   var diffuseColor : Vector4
   var specularColor : Vector4
   var emissiveColor : Vector4
   var shine : float
   var shineStrength : float
   var opacity : float
   var ior : float
   var bDoubleSided : bool # byte
   var bWireframe : bool # byte
   var unused : int # 1 byte
   var numLayers : int # byte
   var name : String
   var Layers : Array[Layer]

   func _init(
      ambientColor : Vector4,
      diffuseColor : Vector4,
      specularColor : Vector4,
      emissiveColor : Vector4,
      shine : float,
      shineStrength : float,
      opacity : float,
      ior : float,
      bDoubleSided : bool,
      bWireframe : bool,
      unused : int,
      numLayers : int,
      name : String
   ) -> void:
      self.ambientColor = ambientColor
      self.diffuseColor = diffuseColor
      self.specularColor = specularColor
      self.emissiveColor = emissiveColor
      self.shine = shine
      self.shineStrength = shineStrength
      self.opacity = opacity
      self.ior = ior
      self.bDoubleSided = bDoubleSided
      self.bWireframe = bWireframe
      self.unused = unused
      self.numLayers = numLayers
      self.name = name

   func setLayers(layers : Array[Layer]) -> void:
      self.Layers = layers

   # Specular textures are used for country-specific unit colours,
   # which need a UnitModel to be set through
   func has_specular() -> bool:
      for layer : Layer in Layers:
         if layer.is_specular():
            return true
      return false

   func debugPrint() -> void:
      print("Material Name: %s, num layers: %d, doubleSided %s" % [name, numLayers, bDoubleSided])
      print("\tshine:%s\tshineStrength:%s\t,opacity:%s,\tior:%s,\tunused:%s" % [shine, shineStrength, opacity, ior, unused])
      for layer : Layer in Layers:
         layer.debugPrint()

# MESH

static func readVerticesAttribute(file : FileAccess, numVerts : int) -> VerticesAttribute:
   var vertAttrib : VerticesAttribute = VerticesAttribute.new(
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file),
      file.get_8(), file.get_8(), Vector2i(file.get_8(), file.get_8()))
   var data : Variant
   match vertAttrib.type:
      0: # position
         data = PackedVector3Array()
         for i : int in numVerts:
            data.push_back(FileAccessUtils.read_pos(file))
      1: # normals
         data = PackedVector3Array()
         for i : int in numVerts:
            data.push_back(FileAccessUtils.read_pos(file))
      2: # tangents
         data = [] as Array[Vector4]
         for i : int in numVerts:
            var tangent : Vector4 = FileAccessUtils.read_vec4(file)
            #tangent.w *= -1
            data.push_back(tangent)
      3: # uvs
         data = PackedVector2Array()
         for i : int in numVerts:
            data.push_back(FileAccessUtils.read_vec2(file))
      4: # 32bit colors
         data = PackedColorArray()
         for i : int in numVerts:
            data.push_back(FileAccessUtils.read_Color32(file))
      5: # influence range indices
         data = PackedInt64Array()
         for i : int in numVerts:
            data.push_back(file.get_32())
      6: # 128bit colors
         data = PackedColorArray()
         for i : int in numVerts:
            data.push_back(FileAccessUtils.read_Color128(file))
      _:
         push_error("INVALID XAC VERTATTRIBUTE TYPE %d" % vertAttrib.type)
   vertAttrib.setData(data)
   return vertAttrib

# mesh has one of these for each vertex property (position, normals, etc)
class VerticesAttribute:
   var type : int # int32
   var attribSize : int # int32
   var bKeepOriginals : bool # byte
   var bIsScaleFactor : bool # byte
   var pad : Vector2i # 2x byte
   var data : Variant # numVerts * attribSize

   func _init(
      type : int,
      attribSize : int,
      bKeepOriginals : bool,
      bIsScaleFactor : bool,
      pad : Vector2i
   ) -> void:
      self.type = type
      self.attribSize = attribSize
      self.bKeepOriginals = bKeepOriginals
      self.bIsScaleFactor = bIsScaleFactor
      self.pad = pad

   func setData(data : Variant) -> void:
      self.data = data

   func debugPrint() -> void:
      var typeStr : String
      match type:
         0:
            typeStr = "Positions"
         1:
            typeStr = "Normals"
         2:
            typeStr = "Tangents"
         3:
            typeStr = "UV Coords"
         4:
            typeStr = "32bit Colors"
         5:
            typeStr = "Influence Range Indices (u32)"
         6:
            typeStr = "128bit Colors"
         _:
            typeStr = "invalid type %d" % type
      print("\tattribSize:%d (bytes),\t keepOriginals:%s,\t isScaleFactor:%s,\t VertAttrib: type:%s" %
         [attribSize, bKeepOriginals, bIsScaleFactor, typeStr])
      print("\tpad: %s" % pad)

static func readSubMesh(file : FileAccess) -> SubMesh:
   var subMesh : SubMesh = SubMesh.new(
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file),
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file)
   )
   var relIndices : PackedInt32Array = PackedInt32Array()
   var boneIds : PackedInt32Array = PackedInt32Array()
   for i : int in subMesh.numIndices:
      relIndices.push_back(FileAccessUtils.read_int32(file))
   for i : int in subMesh.numBones:
      boneIds.push_back(FileAccessUtils.read_int32(file))
   subMesh.setBoneIds(boneIds)
   subMesh.setRelIndices(relIndices)
   return subMesh

class SubMesh:
   var numIndices : int # int32
   var numVertices : int # int32
   var materialId : int # int32
   var numBones : int # int32
   var relativeIndices : PackedInt32Array # int32 [numIndices]
   var boneIds : PackedInt32Array # int32 [numBones], unused

   func _init(numIndices : int, numVertices : int, materialId : int, numBones : int) -> void:
      self.numIndices = numIndices
      self.numVertices = numVertices
      self.materialId = materialId
      self.numBones = numBones

   func setRelIndices(relativeIndices : PackedInt32Array) -> void:
      self.relativeIndices = relativeIndices

   func setBoneIds(boneIds : PackedInt32Array) -> void:
      self.boneIds = boneIds

   func debugPrint() -> void:
      print("\tSubMesh:\t numIndices:%d,\t numVerts:%d,\t matId:%d,\t numBones:%d" %
         [numIndices, numVertices, materialId, numBones])

static func readMeshChunk(file : FileAccess) -> MeshChunk:
   var mesh : MeshChunk = MeshChunk.new(
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file),
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file),
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file), file.get_8(),
      Vector3i(file.get_8(), file.get_8(), file.get_8())
   )
   var vertAttribs : Array[VerticesAttribute] = []
   var submeshes : Array[SubMesh] = []
   for i : int in mesh.numAttribLayers:
      vertAttribs.push_back(readVerticesAttribute(file,mesh.numVertices))
   for i : int in mesh.numSubMeshes:
      submeshes.push_back(readSubMesh(file))
   mesh.setVerticesAttributes(vertAttribs)
   mesh.setSubMeshes(submeshes)
   return mesh

class MeshChunk:
   var nodeId : int # int32
   var numInfluenceRanges : int # int32
   var numVertices : int # int32
   var numIndices : int # int32
   var numSubMeshes : int # int32
   var numAttribLayers : int # int32
   var bIsCollisionMesh : bool # byte
   var pad : Vector3i # 3x byte
   var VerticesAttributes : Array[VerticesAttribute]
   var SubMeshes : Array[SubMesh]

   func _init(
      nodeId : int,
      numInfluenceRanges : int,
      numVertices : int,
      numIndices : int,
      numSubMeshes : int,
      numAttribLayers : int,
      bIsCollisionMesh : bool,
      pad : Vector3i
   ) -> void:
      self.nodeId = nodeId
      self.numInfluenceRanges = numInfluenceRanges
      self.numVertices = numVertices
      self.numIndices = numIndices
      self.numSubMeshes = numSubMeshes
      self.numAttribLayers = numAttribLayers
      self.bIsCollisionMesh = bIsCollisionMesh
      self.pad = pad

   func setVerticesAttributes(VerticesAttributes : Array[VerticesAttribute]) -> void:
      self.VerticesAttributes = VerticesAttributes

   func setSubMeshes(SubMeshes : Array[SubMesh]) -> void:
      self.SubMeshes = SubMeshes

   func debugPrint() -> void:
      print("Mesh: nodeId:%d, numVerts:%d, numSubMeshes:%d, numVertAttribs:%d, isCollisionMesh:%s" %
         [nodeId, numVertices, numSubMeshes, numAttribLayers, bIsCollisionMesh])
      for vertAttrib in VerticesAttributes:
         vertAttrib.debugPrint()
      for subMesh : SubMesh in SubMeshes:
         subMesh.debugPrint()

# SKINNING
static func readInfluenceData(file : FileAccess) -> InfluenceData:
   return InfluenceData.new(file.get_float(), FileAccessUtils.read_int16(file), Vector2i(file.get_8(), file.get_8()))

class InfluenceData:
   var fWeight : float # (0..1)
   var boneId : int # int16
   var pad : Vector2i # 2x byte

   func _init(fWeight : float, boneId : int, pad : Vector2i) -> void:
      self.fWeight = fWeight
      self.boneId = boneId
      self.pad = pad

   func debugPrint() -> void:
      print("\tInfluenceData:\t boneId: %d,\t Weight: %s" % [boneId, fWeight])

# For some reason influenceRange isn't being loaded, needs investigation
# Weird data on the flag

static func readInfluenceRange(file : FileAccess) -> InfluenceRange:
   return InfluenceRange.new(FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file))

class InfluenceRange:
   var firstInfluenceIndex : int # int32
   var numInfluences : int # int32

   func _init(firstInfluenceIndex : int, numInfluences : int) -> void:
      self.firstInfluenceIndex = firstInfluenceIndex
      self.numInfluences = numInfluences

   func debugPrint() -> void:
      print("\tInfluenceRange:\t firstIndex: %d,\t numInfluences: %d" % [firstInfluenceIndex, numInfluences])

static func readSkinningChunk(file : FileAccess, meshChunks : Array[MeshChunk], isV2 : bool) -> SkinningChunk:
   var skinning : SkinningChunk = null
   skinning = SkinningChunk.new(
      FileAccessUtils.read_int32(file), -1 if isV2 else FileAccessUtils.read_int32(file),
      FileAccessUtils.read_int32(file), file.get_8(), Vector3i(file.get_8(), file.get_8(), file.get_8())
   )
   var influenceData : Array[InfluenceData] = []
   var influenceRange : Array[InfluenceRange] = []
   for i : int in skinning.numInfluences:
      influenceData.push_back(readInfluenceData(file))
   # search the list of mesh chunks for the one which matches IsCollisionMesh and NodeId?
   # documentation is a little unclear about this (lists the mesh accessing by node, which isn't possible)
   for chunk : MeshChunk in meshChunks:
      if chunk.nodeId == skinning.nodeId and chunk.bIsCollisionMesh == skinning.bIsForCollisionMesh:
         for i : int in chunk.numInfluenceRanges:
            influenceRange.push_back(readInfluenceRange(file))
         break
   skinning.setInfluenceData(influenceData)
   skinning.setInfluenceRange(influenceRange)
   return skinning

class SkinningChunk:
   var nodeId : int # int32
   var numLocalBones : int # int32, of bones in the influence data
   var numInfluences : int # int32
   var bIsForCollisionMesh : bool # byte boolean
   var pad : Vector3i # 3x pad
   var influenceData : Array[InfluenceData]
   var influenceRange : Array[InfluenceRange]

   func _init(
      nodeId : int,
      numLocalBones : int,
      numInfluences : int,
      bIsForCollisionMesh : bool,
      pad : Vector3i
   ) -> void:
      self.nodeId = nodeId
      self.numLocalBones = numLocalBones
      self.numInfluences = numInfluences
      self.bIsForCollisionMesh = bIsForCollisionMesh
      self.pad = pad

   func setInfluenceData(influenceData : Array[InfluenceData]) -> void:
      self.influenceData = influenceData

   func setInfluenceRange(influenceRange : Array[InfluenceRange]) -> void:
      self.influenceRange = influenceRange

   func debugPrint() -> void:
      print("Skinning: nodeId:%d, numInfluencedBones: %d, numInfluences: %d, CollisionMesh?: %d" %
         [nodeId, numLocalBones, numInfluences, bIsForCollisionMesh])
      for infDat : InfluenceData in influenceData:
         infDat.debugPrint()
      for infRange : InfluenceRange in influenceRange:
         infRange.debugPrint()

# TODO: What is chunk type6, figure out what the plausible datatypes are
# Currently, since XACs tend to use int32s and float (32bit) + strings, and no strings
# are evident in chunk type 6, to load these as arrays of int32

static func readChunkType6(file : FileAccess) -> ChunkType6:
   var intArr : PackedInt32Array = []
   var floatArr : PackedFloat32Array = []
   for i : int in 12:
      intArr.push_back(FileAccessUtils.read_int32(file))
   for i : int in 9:
      floatArr.push_back(file.get_float())
   return ChunkType6.new(intArr, floatArr, FileAccessUtils.read_int32(file))

class ChunkType6:
   var unknown : PackedInt32Array
   var unknown_floats : PackedFloat32Array
   var maybe_node_id : int

   func _init(unknown : PackedInt32Array, unknown_floats : PackedFloat32Array, maybe_node_id : int) -> void:
      self.unknown = unknown
      self.unknown_floats = unknown_floats
      self.maybe_node_id = maybe_node_id

   func debugPrint() -> void:
      print("\tUnknown: %s\n\tFloats: %s\n\tPerhaps NodeId? %s" % [self.unknown, self.unknown_floats, self.maybe_node_id])

# Chunk type 0x0
static func readNodeChunk(file : FileAccess) -> NodeChunk:
   return NodeChunk.new(
      FileAccessUtils.read_quat(file), FileAccessUtils.read_quat(file),
      FileAccessUtils.read_pos(file), FileAccessUtils.read_vec3(file),
      FileAccessUtils.read_vec3(file), # unused 3 floats
      FileAccessUtils.read_int32(file), FileAccessUtils.read_int32(file), #-1-1
      # 17 x 32bit unknowns, likely matrix and some other info
      # last 32bit unknown is likely fImportanceFactor, (float 1f). Rest is likely matrix
      (func() -> PackedInt32Array:
         var array : PackedInt32Array = PackedInt32Array()
         for i : int in 17:
            array.push_back(FileAccessUtils.read_int32(file))
         return array).call(),
      FileAccessUtils.read_xac_str(file)
   )

class NodeChunk:
   var rotation : Quaternion
   var scaleRotation : Quaternion
   var position : Vector3
   var scale : Vector3
   var unused : Vector3 # 3x unused floats
   var unknown : int # int32
   var parentBone : int # int32
   var unknown2 : PackedInt32Array # 17x int32 sized numbers
   var name : String

   func _init(
      rot : Quaternion,
      scaleRot : Quaternion,
      pos : Vector3,
      scale : Vector3,
      unused : Vector3,
      unknown : int,
      parentBone : int,
      unknown2 : PackedInt32Array,
      name : String
   ) -> void:
      self.rotation = rot
      self.scaleRotation = scaleRot
      self.position = pos
      self.scale = scale
      self.unused = unused
      self.unknown = unknown
      self.parentBone = parentBone
      self.unknown2 = unknown2
      self.name = name

   func debugPrint() -> void:
      print("\tNode Name: %s, parentBone %s" % [name, parentBone])
      print("\tunused (%s) unknown: %s" % [unused, unknown])
      print("\tunknown after -1-1: %s" % unknown2)

static func readChunkTypeUnknown(file : FileAccess, length : int) -> ChunkTypeUnknown:
   return ChunkTypeUnknown.new(file.get_buffer(length))

class ChunkTypeUnknown:
   var unknown : PackedByteArray

   func _init(unknown : PackedByteArray) -> void:
      self.unknown = unknown

   func debugPrint() -> void:
      print("\tUnknown: %s" % self.unknown)

# TODO: MorphTarget, Deformation, Transformation, MorphTargetsChunk